2 * crypto.c Encryption support functions
4 * Author: Landon Fuller <landonf@opendarwin.org>
8 * Copyright (C) 2005 Kern Sibbald
10 * This file was contributed to the Bacula project by Landon Fuller.
12 * Landon Fuller has been granted a perpetual, worldwide, non-exclusive,
13 * no-charge, royalty-free, irrevocable copyright license to reproduce,
14 * prepare derivative works of, publicly display, publicly perform,
15 * sublicense, and distribute the original work contributed by Landon Fuller
16 * to the Bacula project in source or object form.
18 * If you wish to license these contributions under an alternate open source
19 * license please contact Landon Fuller <landonf@opendarwin.org>.
22 Copyright (C) 2005-2006 Kern Sibbald
24 This program is free software; you can redistribute it and/or
25 modify it under the terms of the GNU General Public License
26 version 2 as amended with additional clauses defined in the
27 file LICENSE in the main source directory.
29 This program is distributed in the hope that it will be useful,
30 but WITHOUT ANY WARRANTY; without even the implied warranty of
31 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
32 the file LICENSE for additional details.
44 * Prefix: iso.org.dod.internet.private.enterprise.threerings.external.bacula (1.3.6.1.4.1.22054.500.2)
45 * Organization: Bacula Project
46 * Contact Name: Kern Sibbald
47 * Contact E-mail: kern@sibbald.com
49 * Top Level Allocations - 500.2
50 * 1 - Published Allocations
51 * 1.1 - Bacula Encryption
53 * Bacula Encryption - 500.2.1.1
56 * 2 - ASN.1 Object Identifiers
62 * BaculaCrypto { iso(1) identified-organization(3) usdod(6)
63 * internet(1) private(4) enterprises(1) three-rings(22054)
64 * external(500) bacula(2) published(1) bacula-encryption(1)
65 * asn1-modules(1) bacula-crypto(1) }
67 * DEFINITIONS AUTOMATIC TAGS ::=
70 * SignatureData ::= SEQUENCE {
71 * version Version DEFAULT v0,
72 * signerInfo SignerInfo }
74 * CryptoData ::= SEQUENCE {
75 * version Version DEFAULT v0,
76 * contentEncryptionAlgorithm ContentEncryptionAlgorithmIdentifier,
77 * iv InitializationVector,
78 * recipientInfo RecipientInfo
81 * SignerInfo ::= SET OF SignerInfo
82 * RecipientInfo ::= SET OF RecipientInfo
84 * Version ::= INTEGER { v0(0) }
86 * SignerInfo ::= SEQUENCE {
88 * subjectKeyIdentifier SubjectKeyIdentifier,
89 * digestAlgorithm DigestAlgorithmIdentifier,
90 * signatureAlgorithm SignatureAlgorithmIdentifier,
91 * signature SignatureValue }
93 * RecipientInfo ::= SEQUENCE {
95 * subjectKeyIdentifier SubjectKeyIdentifier
96 * keyEncryptionAlgorithm KeyEncryptionAlgorithmIdentifier
97 * encryptedKey EncryptedKey
100 * SubjectKeyIdentifier ::= OCTET STRING
102 * DigestAlgorithmIdentifier ::= AlgorithmIdentifier
104 * SignatureAlgorithmIdentifier ::= AlgorithmIdentifier
106 * KeyEncryptionAlgorithmIdentifier ::= AlgorithmIdentifier
108 * ContentEncryptionAlgorithmIdentifier ::= AlgorithmIdentifier
110 * InitializationVector ::= OCTET STRING
112 * SignatureValue ::= OCTET STRING
114 * EncryptedKey ::= OCTET STRING
116 * AlgorithmIdentifier ::= OBJECT IDENTIFIER
121 #ifdef HAVE_CRYPTO /* Is encryption enabled? */
122 #ifdef HAVE_OPENSSL /* How about OpenSSL? */
124 /* Are we initialized? */
125 static int crypto_initialized = false;
127 /* ASN.1 Declarations */
128 #define BACULA_ASN1_VERSION 0
131 ASN1_INTEGER *version;
132 ASN1_OCTET_STRING *subjectKeyIdentifier;
133 ASN1_OBJECT *digestAlgorithm;
134 ASN1_OBJECT *signatureAlgorithm;
135 ASN1_OCTET_STRING *signature;
139 ASN1_INTEGER *version;
140 ASN1_OCTET_STRING *subjectKeyIdentifier;
141 ASN1_OBJECT *keyEncryptionAlgorithm;
142 ASN1_OCTET_STRING *encryptedKey;
145 ASN1_SEQUENCE(SignerInfo) = {
146 ASN1_SIMPLE(SignerInfo, version, ASN1_INTEGER),
147 ASN1_SIMPLE(SignerInfo, subjectKeyIdentifier, ASN1_OCTET_STRING),
148 ASN1_SIMPLE(SignerInfo, digestAlgorithm, ASN1_OBJECT),
149 ASN1_SIMPLE(SignerInfo, signatureAlgorithm, ASN1_OBJECT),
150 ASN1_SIMPLE(SignerInfo, signature, ASN1_OCTET_STRING)
151 } ASN1_SEQUENCE_END(SignerInfo);
153 ASN1_SEQUENCE(RecipientInfo) = {
154 ASN1_SIMPLE(RecipientInfo, version, ASN1_INTEGER),
155 ASN1_SIMPLE(RecipientInfo, subjectKeyIdentifier, ASN1_OCTET_STRING),
156 ASN1_SIMPLE(RecipientInfo, keyEncryptionAlgorithm, ASN1_OBJECT),
157 ASN1_SIMPLE(RecipientInfo, encryptedKey, ASN1_OCTET_STRING),
158 } ASN1_SEQUENCE_END(RecipientInfo);
161 ASN1_INTEGER *version;
162 STACK_OF(SignerInfo) *signerInfo;
166 ASN1_INTEGER *version;
167 ASN1_OBJECT *contentEncryptionAlgorithm;
168 ASN1_OCTET_STRING *iv;
169 STACK_OF(RecipientInfo) *recipientInfo;
172 ASN1_SEQUENCE(SignatureData) = {
173 ASN1_SIMPLE(SignatureData, version, ASN1_INTEGER),
174 ASN1_SET_OF(SignatureData, signerInfo, SignerInfo),
175 } ASN1_SEQUENCE_END(SignatureData);
177 ASN1_SEQUENCE(CryptoData) = {
178 ASN1_SIMPLE(CryptoData, version, ASN1_INTEGER),
179 ASN1_SIMPLE(CryptoData, contentEncryptionAlgorithm, ASN1_OBJECT),
180 ASN1_SIMPLE(CryptoData, iv, ASN1_OCTET_STRING),
181 ASN1_SET_OF(CryptoData, recipientInfo, RecipientInfo)
182 } ASN1_SEQUENCE_END(CryptoData);
184 IMPLEMENT_ASN1_FUNCTIONS(SignerInfo)
185 IMPLEMENT_ASN1_FUNCTIONS(RecipientInfo)
186 IMPLEMENT_ASN1_FUNCTIONS(SignatureData)
187 IMPLEMENT_ASN1_FUNCTIONS(CryptoData)
188 IMPLEMENT_STACK_OF(SignerInfo)
189 IMPLEMENT_STACK_OF(RecipientInfo)
192 * SignerInfo and RecipientInfo stack macros, generated by OpenSSL's util/mkstack.pl.
194 #define sk_SignerInfo_new(st) SKM_sk_new(SignerInfo, (st))
195 #define sk_SignerInfo_new_null() SKM_sk_new_null(SignerInfo)
196 #define sk_SignerInfo_free(st) SKM_sk_free(SignerInfo, (st))
197 #define sk_SignerInfo_num(st) SKM_sk_num(SignerInfo, (st))
198 #define sk_SignerInfo_value(st, i) SKM_sk_value(SignerInfo, (st), (i))
199 #define sk_SignerInfo_set(st, i, val) SKM_sk_set(SignerInfo, (st), (i), (val))
200 #define sk_SignerInfo_zero(st) SKM_sk_zero(SignerInfo, (st))
201 #define sk_SignerInfo_push(st, val) SKM_sk_push(SignerInfo, (st), (val))
202 #define sk_SignerInfo_unshift(st, val) SKM_sk_unshift(SignerInfo, (st), (val))
203 #define sk_SignerInfo_find(st, val) SKM_sk_find(SignerInfo, (st), (val))
204 #define sk_SignerInfo_delete(st, i) SKM_sk_delete(SignerInfo, (st), (i))
205 #define sk_SignerInfo_delete_ptr(st, ptr) SKM_sk_delete_ptr(SignerInfo, (st), (ptr))
206 #define sk_SignerInfo_insert(st, val, i) SKM_sk_insert(SignerInfo, (st), (val), (i))
207 #define sk_SignerInfo_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(SignerInfo, (st), (cmp))
208 #define sk_SignerInfo_dup(st) SKM_sk_dup(SignerInfo, st)
209 #define sk_SignerInfo_pop_free(st, free_func) SKM_sk_pop_free(SignerInfo, (st), (free_func))
210 #define sk_SignerInfo_shift(st) SKM_sk_shift(SignerInfo, (st))
211 #define sk_SignerInfo_pop(st) SKM_sk_pop(SignerInfo, (st))
212 #define sk_SignerInfo_sort(st) SKM_sk_sort(SignerInfo, (st))
213 #define sk_SignerInfo_is_sorted(st) SKM_sk_is_sorted(SignerInfo, (st))
215 #define d2i_ASN1_SET_OF_SignerInfo(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \
216 SKM_ASN1_SET_OF_d2i(SignerInfo, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class))
217 #define i2d_ASN1_SET_OF_SignerInfo(st, pp, i2d_func, ex_tag, ex_class, is_set) \
218 SKM_ASN1_SET_OF_i2d(SignerInfo, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set))
219 #define ASN1_seq_pack_SignerInfo(st, i2d_func, buf, len) \
220 SKM_ASN1_seq_pack(SignerInfo, (st), (i2d_func), (buf), (len))
221 #define ASN1_seq_unpack_SignerInfo(buf, len, d2i_func, free_func) \
222 SKM_ASN1_seq_unpack(SignerInfo, (buf), (len), (d2i_func), (free_func))
224 #define sk_RecipientInfo_new(st) SKM_sk_new(RecipientInfo, (st))
225 #define sk_RecipientInfo_new_null() SKM_sk_new_null(RecipientInfo)
226 #define sk_RecipientInfo_free(st) SKM_sk_free(RecipientInfo, (st))
227 #define sk_RecipientInfo_num(st) SKM_sk_num(RecipientInfo, (st))
228 #define sk_RecipientInfo_value(st, i) SKM_sk_value(RecipientInfo, (st), (i))
229 #define sk_RecipientInfo_set(st, i, val) SKM_sk_set(RecipientInfo, (st), (i), (val))
230 #define sk_RecipientInfo_zero(st) SKM_sk_zero(RecipientInfo, (st))
231 #define sk_RecipientInfo_push(st, val) SKM_sk_push(RecipientInfo, (st), (val))
232 #define sk_RecipientInfo_unshift(st, val) SKM_sk_unshift(RecipientInfo, (st), (val))
233 #define sk_RecipientInfo_find(st, val) SKM_sk_find(RecipientInfo, (st), (val))
234 #define sk_RecipientInfo_delete(st, i) SKM_sk_delete(RecipientInfo, (st), (i))
235 #define sk_RecipientInfo_delete_ptr(st, ptr) SKM_sk_delete_ptr(RecipientInfo, (st), (ptr))
236 #define sk_RecipientInfo_insert(st, val, i) SKM_sk_insert(RecipientInfo, (st), (val), (i))
237 #define sk_RecipientInfo_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(RecipientInfo, (st), (cmp))
238 #define sk_RecipientInfo_dup(st) SKM_sk_dup(RecipientInfo, st)
239 #define sk_RecipientInfo_pop_free(st, free_func) SKM_sk_pop_free(RecipientInfo, (st), (free_func))
240 #define sk_RecipientInfo_shift(st) SKM_sk_shift(RecipientInfo, (st))
241 #define sk_RecipientInfo_pop(st) SKM_sk_pop(RecipientInfo, (st))
242 #define sk_RecipientInfo_sort(st) SKM_sk_sort(RecipientInfo, (st))
243 #define sk_RecipientInfo_is_sorted(st) SKM_sk_is_sorted(RecipientInfo, (st))
245 #define d2i_ASN1_SET_OF_RecipientInfo(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \
246 SKM_ASN1_SET_OF_d2i(RecipientInfo, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class))
247 #define i2d_ASN1_SET_OF_RecipientInfo(st, pp, i2d_func, ex_tag, ex_class, is_set) \
248 SKM_ASN1_SET_OF_i2d(RecipientInfo, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set))
249 #define ASN1_seq_pack_RecipientInfo(st, i2d_func, buf, len) \
250 SKM_ASN1_seq_pack(RecipientInfo, (st), (i2d_func), (buf), (len))
251 #define ASN1_seq_unpack_RecipientInfo(buf, len, d2i_func, free_func) \
252 SKM_ASN1_seq_unpack(RecipientInfo, (buf), (len), (d2i_func), (free_func))
253 /* End of util/mkstack.pl block */
255 /* X509 Public/Private Key Pair Structure */
256 struct X509_Keypair {
257 ASN1_OCTET_STRING *keyid;
262 /* Message Digest Structure */
264 crypto_digest_t type;
268 /* Message Signature Structure */
270 SignatureData *sigData;
273 /* Encryption Session Data */
274 struct Crypto_Session {
275 CryptoData *cryptoData; /* ASN.1 Structure */
276 unsigned char *session_key; /* Private symmetric session key */
277 size_t session_key_len; /* Symmetric session key length */
280 /* Symmetric Cipher Context */
281 struct Cipher_Context {
285 /* PEM Password Dispatch Context */
286 typedef struct PEM_CB_Context {
287 CRYPTO_PEM_PASSWD_CB *pem_callback;
288 const void *pem_userdata;
292 * Extract subjectKeyIdentifier from x509 certificate.
293 * Returns: On success, an ASN1_OCTET_STRING that must be freed via M_ASN1_OCTET_STRING_free().
296 static ASN1_OCTET_STRING *openssl_cert_keyid(X509 *cert){
298 X509V3_EXT_METHOD *method;
299 ASN1_OCTET_STRING *keyid;
301 #if (OPENSSL_VERSION_NUMBER >= 0x0090800FL)
302 const unsigned char *ext_value_data;
304 unsigned char *ext_value_data;
308 /* Find the index to the subjectKeyIdentifier extension */
309 i = X509_get_ext_by_NID(cert, NID_subject_key_identifier, -1);
315 /* Grab the extension */
316 ext = X509_get_ext(cert, i);
318 /* Get x509 extension method structure */
319 if (!(method = X509V3_EXT_get(ext))) {
323 ext_value_data = ext->value->data;
325 #if (OPENSSL_VERSION_NUMBER > 0x00907000L)
329 /* Decode ASN1 item in data */
330 keyid = (ASN1_OCTET_STRING *) ASN1_item_d2i(NULL, &ext_value_data, ext->value->length,
331 ASN1_ITEM_ptr(method->it));
335 /* Decode ASN1 item in data */
336 keyid = (ASN1_OCTET_STRING *) method->d2i(NULL, &ext_value_data, ext->value->length);
340 keyid = (ASN1_OCTET_STRING *) method->d2i(NULL, &ext_value_data, ext->value->length);
347 * Create a new keypair object.
348 * Returns: A pointer to a X509 KEYPAIR object on success.
351 X509_KEYPAIR *crypto_keypair_new (void) {
352 X509_KEYPAIR *keypair;
354 /* Allocate our keypair structure */
355 keypair = (X509_KEYPAIR *) malloc(sizeof(X509_KEYPAIR));
360 /* Initialize our keypair structure */
361 keypair->keyid = NULL;
362 keypair->pubkey = NULL;
363 keypair->privkey = NULL;
369 * Create a copy of a keypair object. The underlying
370 * EVP objects are not duplicated, as no EVP_PKEY_dup()
371 * API is available. Instead, the reference count is
374 X509_KEYPAIR *crypto_keypair_dup (X509_KEYPAIR *keypair)
376 X509_KEYPAIR *newpair;
378 newpair = crypto_keypair_new();
381 /* Allocation failed */
385 /* Increment the public key ref count */
386 if (keypair->pubkey) {
387 CRYPTO_add(&(keypair->pubkey->references), 1, CRYPTO_LOCK_EVP_PKEY);
388 newpair->pubkey = keypair->pubkey;
391 /* Increment the private key ref count */
392 if (keypair->privkey) {
393 CRYPTO_add(&(keypair->privkey->references), 1, CRYPTO_LOCK_EVP_PKEY);
394 newpair->privkey = keypair->privkey;
397 /* Duplicate the keyid */
398 if (keypair->keyid) {
399 newpair->keyid = M_ASN1_OCTET_STRING_dup(keypair->keyid);
400 if (!newpair->keyid) {
401 /* Allocation failed */
402 crypto_keypair_free(newpair);
412 * Load a public key from a PEM-encoded x509 certificate.
413 * Returns: true on success
416 int crypto_keypair_load_cert (X509_KEYPAIR *keypair, const char *file)
422 if (!(bio = BIO_new_file(file, "r"))) {
423 openssl_post_errors(M_ERROR, _("Unable to open certificate file"));
427 cert = PEM_read_bio_X509(bio, NULL, NULL, NULL);
430 openssl_post_errors(M_ERROR, _("Unable to read certificate from file"));
434 /* Extract the public key */
435 if (!(keypair->pubkey = X509_get_pubkey(cert))) {
436 openssl_post_errors(M_ERROR, _("Unable to extract public key from certificate"));
440 /* Extract the subjectKeyIdentifier extension field */
441 if ((keypair->keyid = openssl_cert_keyid(cert)) == NULL) {
442 Emsg0(M_ERROR, 0, _("Provided certificate does not include the required subjectKeyIdentifier extension."));
446 /* Validate the public key type (only RSA is supported) */
447 if (EVP_PKEY_type(keypair->pubkey->type) != EVP_PKEY_RSA) {
448 Emsg1(M_ERROR, 0, _("Unsupported key type provided: %d\n"), EVP_PKEY_type(keypair->pubkey->type));
457 if (keypair->pubkey) {
458 EVP_PKEY_free(keypair->pubkey);
463 /* Dispatch user PEM encryption callbacks */
464 static int crypto_pem_callback_dispatch (char *buf, int size, int rwflag, void *userdata)
466 PEM_CB_CONTEXT *ctx = (PEM_CB_CONTEXT *) userdata;
467 return (ctx->pem_callback(buf, size, ctx->pem_userdata));
471 * Check a PEM-encoded file
472 * for the existence of a private key.
473 * Returns: true if a private key is found
476 bool crypto_keypair_has_key (const char *file) {
480 unsigned char *data = NULL;
484 if (!(bio = BIO_new_file(file, "r"))) {
485 openssl_post_errors(M_ERROR, _("Unable to open private key file"));
489 while (PEM_read_bio(bio, &name, &header, &data, &len)) {
490 /* We don't care what the data is, just that it's there */
491 OPENSSL_free(header);
495 * PEM Header Found, check for a private key
496 * Due to OpenSSL limitations, we must specifically
497 * list supported PEM private key encodings.
499 if (strcmp(name, PEM_STRING_RSA) == 0
500 || strcmp(name, PEM_STRING_DSA) == 0
501 || strcmp(name, PEM_STRING_PKCS8) == 0
502 || strcmp(name, PEM_STRING_PKCS8INF) == 0) {
514 /* Post PEM-decoding error messages, if any */
515 openssl_post_errors(M_ERROR, _("Unable to read private key from file"));
520 * Load a PEM-encoded private key.
521 * Returns: true on success
524 int crypto_keypair_load_key (X509_KEYPAIR *keypair, const char *file,
525 CRYPTO_PEM_PASSWD_CB *pem_callback,
526 const void *pem_userdata)
532 if (!(bio = BIO_new_file(file, "r"))) {
533 openssl_post_errors(M_ERROR, _("Unable to open private key file"));
537 /* Set up PEM encryption callback */
539 ctx.pem_callback = pem_callback;
540 ctx.pem_userdata = pem_userdata;
542 ctx.pem_callback = crypto_default_pem_callback;
543 ctx.pem_userdata = NULL;
546 keypair->privkey = PEM_read_bio_PrivateKey(bio, NULL, crypto_pem_callback_dispatch, &ctx);
548 if (!keypair->privkey) {
549 openssl_post_errors(M_ERROR, _("Unable to read private key from file"));
557 * Free memory associated with a keypair object.
559 void crypto_keypair_free (X509_KEYPAIR *keypair)
561 if (keypair->pubkey) {
562 EVP_PKEY_free(keypair->pubkey);
564 if (keypair->privkey) {
565 EVP_PKEY_free(keypair->privkey);
567 if (keypair->keyid) {
568 M_ASN1_OCTET_STRING_free(keypair->keyid);
574 * Create a new message digest context of the specified type
575 * Returns: A pointer to a DIGEST object on success.
578 DIGEST *crypto_digest_new (crypto_digest_t type)
581 const EVP_MD *md = NULL; /* Quell invalid uninitialized warnings */
583 digest = (DIGEST *)malloc(sizeof(DIGEST));
586 /* Initialize the OpenSSL message digest context */
587 EVP_MD_CTX_init(&digest->ctx);
589 /* Determine the correct OpenSSL message digest type */
591 case CRYPTO_DIGEST_MD5:
594 case CRYPTO_DIGEST_SHA1:
598 case CRYPTO_DIGEST_SHA256:
601 case CRYPTO_DIGEST_SHA512:
606 Emsg1(M_ERROR, 0, _("Unsupported digest type: %d\n"), type);
610 /* Initialize the backing OpenSSL context */
611 if (EVP_DigestInit_ex(&digest->ctx, md, NULL) == 0) {
618 /* This should not happen, but never say never ... */
619 openssl_post_errors(M_ERROR, _("OpenSSL digest initialization failed"));
620 crypto_digest_free(digest);
625 * Hash length bytes of data into the provided digest context.
626 * Returns: true on success
629 bool crypto_digest_update(DIGEST *digest, const uint8_t *data, uint32_t length)
631 if (EVP_DigestUpdate(&digest->ctx, data, length) == 0) {
639 * Finalize the data in digest, storing the result in dest and the result size
640 * in length. The result size can be determined with crypto_digest_size().
642 * Returns: true on success
645 bool crypto_digest_finalize (DIGEST *digest, uint8_t *dest, uint32_t *length) {
646 if (!EVP_DigestFinal(&digest->ctx, dest, (unsigned int *)length)) {
654 * Free memory associated with a digest object.
656 void crypto_digest_free (DIGEST *digest)
658 EVP_MD_CTX_cleanup(&digest->ctx);
663 * Create a new message signature context.
664 * Returns: A pointer to a SIGNATURE object on success.
667 SIGNATURE *crypto_sign_new (void)
671 sig = (SIGNATURE *) malloc(sizeof(SIGNATURE));
676 sig->sigData = SignatureData_new();
679 /* Allocation failed in OpenSSL */
684 /* Set the ASN.1 structure version number */
685 ASN1_INTEGER_set(sig->sigData->version, BACULA_ASN1_VERSION);
691 * For a given public key, find the associated SignatureInfo record
692 * and create a digest context for signature validation
693 * Returns: CRYPTO_ERROR_NONE on success, with the newly allocated DIGEST in digest.
694 * A crypto_error_t value on failure.
696 crypto_error_t crypto_sign_get_digest(SIGNATURE *sig, X509_KEYPAIR *keypair, DIGEST **digest)
698 STACK_OF(SignerInfo) *signers;
702 signers = sig->sigData->signerInfo;
704 for (i = 0; i < sk_SignerInfo_num(signers); i++) {
705 si = sk_SignerInfo_value(signers, i);
706 if (M_ASN1_OCTET_STRING_cmp(keypair->keyid, si->subjectKeyIdentifier) == 0) {
707 /* Get the digest algorithm and allocate a digest context */
708 switch (OBJ_obj2nid(si->digestAlgorithm)) {
710 *digest = crypto_digest_new(CRYPTO_DIGEST_MD5);
713 *digest = crypto_digest_new(CRYPTO_DIGEST_SHA1);
717 *digest = crypto_digest_new(CRYPTO_DIGEST_SHA256);
720 *digest = crypto_digest_new(CRYPTO_DIGEST_SHA512);
725 return CRYPTO_ERROR_INVALID_DIGEST;
728 /* Shouldn't happen */
729 if (*digest == NULL) {
730 return CRYPTO_ERROR_INVALID_DIGEST;
732 return CRYPTO_ERROR_NONE;
737 return CRYPTO_ERROR_NOSIGNER;
741 * For a given signature, public key, and digest, verify the SIGNATURE.
742 * Returns: CRYPTO_ERROR_NONE on success.
743 * A crypto_error_t value on failure.
745 crypto_error_t crypto_sign_verify(SIGNATURE *sig, X509_KEYPAIR *keypair, DIGEST *digest)
747 STACK_OF(SignerInfo) *signers;
751 #if (OPENSSL_VERSION_NUMBER >= 0x0090800FL)
752 const unsigned char *sigData;
754 unsigned char *sigData;
757 signers = sig->sigData->signerInfo;
759 /* Find the signer */
760 for (i = 0; i < sk_SignerInfo_num(signers); i++) {
761 si = sk_SignerInfo_value(signers, i);
762 if (M_ASN1_OCTET_STRING_cmp(keypair->keyid, si->subjectKeyIdentifier) == 0) {
763 /* Extract the signature data */
764 sigLen = M_ASN1_STRING_length(si->signature);
765 sigData = M_ASN1_STRING_data(si->signature);
767 ok = EVP_VerifyFinal(&digest->ctx, sigData, sigLen, keypair->pubkey);
769 return CRYPTO_ERROR_NONE;
770 } else if (ok == 0) {
771 return CRYPTO_ERROR_BAD_SIGNATURE;
773 /* Shouldn't happen */
774 openssl_post_errors(M_ERROR, _("OpenSSL error occured"));
775 return CRYPTO_ERROR_INTERNAL;
780 /* Signer wasn't found. */
781 return CRYPTO_ERROR_NOSIGNER;
787 * Returns: true on success
790 int crypto_sign_add_signer(SIGNATURE *sig, DIGEST *digest, X509_KEYPAIR *keypair)
792 SignerInfo *si = NULL;
793 unsigned char *buf = NULL;
796 si = SignerInfo_new();
799 /* Allocation failed in OpenSSL */
803 /* Set the ASN.1 structure version number */
804 ASN1_INTEGER_set(si->version, BACULA_ASN1_VERSION);
806 /* Set the digest algorithm identifier */
807 switch (digest->type) {
808 case CRYPTO_DIGEST_MD5:
809 si->digestAlgorithm = OBJ_nid2obj(NID_md5);
811 case CRYPTO_DIGEST_SHA1:
812 si->digestAlgorithm = OBJ_nid2obj(NID_sha1);
815 case CRYPTO_DIGEST_SHA256:
816 si->digestAlgorithm = OBJ_nid2obj(NID_sha256);
818 case CRYPTO_DIGEST_SHA512:
819 si->digestAlgorithm = OBJ_nid2obj(NID_sha512);
823 /* This should never happen */
827 /* Drop the string allocated by OpenSSL, and add our subjectKeyIdentifier */
828 M_ASN1_OCTET_STRING_free(si->subjectKeyIdentifier);
829 si->subjectKeyIdentifier = M_ASN1_OCTET_STRING_dup(keypair->keyid);
831 /* Set our signature algorithm. We currently require RSA */
832 assert(EVP_PKEY_type(keypair->pubkey->type) == EVP_PKEY_RSA);
833 /* This is slightly evil. Reach into the MD structure and grab the key type */
834 si->signatureAlgorithm = OBJ_nid2obj(digest->ctx.digest->pkey_type);
836 /* Finalize/Sign our Digest */
837 len = EVP_PKEY_size(keypair->privkey);
838 buf = (unsigned char *) malloc(len);
839 if (!EVP_SignFinal(&digest->ctx, buf, &len, keypair->privkey)) {
840 openssl_post_errors(M_ERROR, _("Signature creation failed"));
844 /* Add the signature to the SignerInfo structure */
845 if (!M_ASN1_OCTET_STRING_set(si->signature, buf, len)) {
846 /* Allocation failed in OpenSSL */
850 /* No longer needed */
853 /* Push the new SignerInfo structure onto the stack */
854 sk_SignerInfo_push(sig->sigData->signerInfo, si);
870 * Encodes the SignatureData structure. The length argument is used to specify the
871 * size of dest. A length of 0 will cause no data to be written to dest, and the
872 * required length to be written to length. The caller can then allocate sufficient
873 * space for the output.
875 * Returns: true on success, stores the encoded data in dest, and the size in length.
878 int crypto_sign_encode(SIGNATURE *sig, uint8_t *dest, size_t *length)
881 *length = i2d_SignatureData(sig->sigData, NULL);
885 *length = i2d_SignatureData(sig->sigData, (unsigned char **)&dest);
890 * Decodes the SignatureData structure. The length argument is used to specify the
893 * Returns: SIGNATURE instance on success.
898 SIGNATURE *crypto_sign_decode(const uint8_t *sigData, size_t length)
901 #if (OPENSSL_VERSION_NUMBER >= 0x0090800FL)
902 const unsigned char *p = (const unsigned char *) sigData;
904 unsigned char *p = (unsigned char *)sigData;
907 sig = (SIGNATURE *)malloc(sizeof(SIGNATURE));
912 /* d2i_SignatureData modifies the supplied pointer */
913 sig->sigData = d2i_SignatureData(NULL, &p, length);
916 /* Allocation / Decoding failed in OpenSSL */
917 openssl_post_errors(M_ERROR, _("Signature decoding failed"));
926 * Free memory associated with a signature object.
928 void crypto_sign_free(SIGNATURE *sig)
930 SignatureData_free(sig->sigData);
935 * Create a new encryption session.
936 * Returns: A pointer to a CRYPTO_SESSION object on success.
939 CRYPTO_SESSION *crypto_session_new (crypto_cipher_t cipher, alist *pubkeys)
942 X509_KEYPAIR *keypair;
943 const EVP_CIPHER *ec;
947 /* Allocate our session description structures */
948 cs = (CRYPTO_SESSION *) malloc(sizeof(CRYPTO_SESSION));
953 /* Initialize required fields */
954 cs->session_key = NULL;
956 /* Allocate a CryptoData structure */
957 cs->cryptoData = CryptoData_new();
959 if (!cs->cryptoData) {
960 /* Allocation failed in OpenSSL */
965 /* Set the ASN.1 structure version number */
966 ASN1_INTEGER_set(cs->cryptoData->version, BACULA_ASN1_VERSION);
969 * Acquire a cipher instance and set the ASN.1 cipher NID
972 case CRYPTO_CIPHER_AES_128_CBC:
973 /* AES 128 bit CBC */
974 cs->cryptoData->contentEncryptionAlgorithm = OBJ_nid2obj(NID_aes_128_cbc);
975 ec = EVP_aes_128_cbc();
977 case CRYPTO_CIPHER_AES_192_CBC:
978 /* AES 192 bit CBC */
979 cs->cryptoData->contentEncryptionAlgorithm = OBJ_nid2obj(NID_aes_192_cbc);
980 ec = EVP_aes_192_cbc();
982 case CRYPTO_CIPHER_AES_256_CBC:
983 /* AES 256 bit CBC */
984 cs->cryptoData->contentEncryptionAlgorithm = OBJ_nid2obj(NID_aes_256_cbc);
985 ec = EVP_aes_256_cbc();
987 case CRYPTO_CIPHER_BLOWFISH_CBC:
989 cs->cryptoData->contentEncryptionAlgorithm = OBJ_nid2obj(NID_bf_cbc);
993 Emsg0(M_ERROR, 0, _("Unsupported cipher type specified\n"));
994 crypto_session_free(cs);
998 /* Generate a symmetric session key */
999 cs->session_key_len = EVP_CIPHER_key_length(ec);
1000 cs->session_key = (unsigned char *) malloc(cs->session_key_len);
1001 if (RAND_bytes(cs->session_key, cs->session_key_len) <= 0) {
1002 /* OpenSSL failure */
1003 crypto_session_free(cs);
1007 /* Generate an IV if possible */
1008 if ((iv_len = EVP_CIPHER_iv_length(ec))) {
1009 iv = (unsigned char *) malloc(iv_len);
1011 /* Malloc failure */
1012 crypto_session_free(cs);
1016 /* Generate random IV */
1017 if (RAND_bytes(iv, iv_len) <= 0) {
1018 /* OpenSSL failure */
1019 crypto_session_free(cs);
1024 /* Store it in our ASN.1 structure */
1025 if (!M_ASN1_OCTET_STRING_set(cs->cryptoData->iv, iv, iv_len)) {
1026 /* Allocation failed in OpenSSL */
1027 crypto_session_free(cs);
1035 * Create RecipientInfo structures for supplied
1038 foreach_alist(keypair, pubkeys) {
1040 unsigned char *ekey;
1043 ri = RecipientInfo_new();
1045 /* Allocation failed in OpenSSL */
1046 crypto_session_free(cs);
1050 /* Set the ASN.1 structure version number */
1051 ASN1_INTEGER_set(ri->version, BACULA_ASN1_VERSION);
1053 /* Drop the string allocated by OpenSSL, and add our subjectKeyIdentifier */
1054 M_ASN1_OCTET_STRING_free(ri->subjectKeyIdentifier);
1055 ri->subjectKeyIdentifier = M_ASN1_OCTET_STRING_dup(keypair->keyid);
1057 /* Set our key encryption algorithm. We currently require RSA */
1058 assert(keypair->pubkey && EVP_PKEY_type(keypair->pubkey->type) == EVP_PKEY_RSA);
1059 ri->keyEncryptionAlgorithm = OBJ_nid2obj(NID_rsaEncryption);
1061 /* Encrypt the session key */
1062 ekey = (unsigned char *) malloc(EVP_PKEY_size(keypair->pubkey));
1064 RecipientInfo_free(ri);
1065 crypto_session_free(cs);
1069 if ((ekey_len = EVP_PKEY_encrypt(ekey, cs->session_key, cs->session_key_len, keypair->pubkey)) <= 0) {
1070 /* OpenSSL failure */
1071 RecipientInfo_free(ri);
1072 crypto_session_free(cs);
1077 /* Store it in our ASN.1 structure */
1078 if (!M_ASN1_OCTET_STRING_set(ri->encryptedKey, ekey, ekey_len)) {
1079 /* Allocation failed in OpenSSL */
1080 RecipientInfo_free(ri);
1081 crypto_session_free(cs);
1086 /* Free the encrypted key buffer */
1089 /* Push the new RecipientInfo structure onto the stack */
1090 sk_RecipientInfo_push(cs->cryptoData->recipientInfo, ri);
1097 * Encodes the CryptoData structure. The length argument is used to specify the
1098 * size of dest. A length of 0 will cause no data to be written to dest, and the
1099 * required length to be written to length. The caller can then allocate sufficient
1100 * space for the output.
1102 * Returns: true on success, stores the encoded data in dest, and the size in length.
1105 bool crypto_session_encode(CRYPTO_SESSION *cs, uint8_t *dest, size_t *length)
1108 *length = i2d_CryptoData(cs->cryptoData, NULL);
1112 *length = i2d_CryptoData(cs->cryptoData, &dest);
1117 * Decodes the CryptoData structure. The length argument is
1118 * used to specify the size of data.
1120 * Returns: CRYPTO_SESSION instance on success.
1122 * Returns: CRYPTO_ERROR_NONE and a pointer to a newly allocated CRYPTO_SESSION structure in *session on success.
1123 * A crypto_error_t value on failure.
1125 crypto_error_t crypto_session_decode(const uint8_t *data, size_t length, alist *keypairs, CRYPTO_SESSION **session)
1128 X509_KEYPAIR *keypair;
1129 STACK_OF(RecipientInfo) *recipients;
1130 crypto_error_t retval = CRYPTO_ERROR_NONE;
1131 #if (OPENSSL_VERSION_NUMBER >= 0x0090800FL)
1132 const unsigned char *p = (const unsigned char *)data;
1134 unsigned char *p = (unsigned char *)data;
1137 cs = (CRYPTO_SESSION *) malloc(sizeof(CRYPTO_SESSION));
1139 return CRYPTO_ERROR_INTERNAL;
1142 /* Initialize required fields */
1143 cs->session_key = NULL;
1145 /* d2i_CryptoData modifies the supplied pointer */
1146 cs->cryptoData = d2i_CryptoData(NULL, &p, length);
1148 if (!cs->cryptoData) {
1149 /* Allocation / Decoding failed in OpenSSL */
1150 openssl_post_errors(M_ERROR, _("CryptoData decoding failed"));
1151 retval = CRYPTO_ERROR_INTERNAL;
1155 recipients = cs->cryptoData->recipientInfo;
1158 * Find a matching RecipientInfo structure for a supplied
1161 foreach_alist(keypair, keypairs) {
1165 /* Private key available? */
1166 if (keypair->privkey == NULL) {
1170 for (i = 0; i < sk_RecipientInfo_num(recipients); i++) {
1171 ri = sk_RecipientInfo_value(recipients, i);
1173 /* Match against the subjectKeyIdentifier */
1174 if (M_ASN1_OCTET_STRING_cmp(keypair->keyid, ri->subjectKeyIdentifier) == 0) {
1175 /* Match found, extract symmetric encryption session data */
1177 /* RSA is required. */
1178 assert(EVP_PKEY_type(keypair->privkey->type) == EVP_PKEY_RSA);
1180 /* If we recieve a RecipientInfo structure that does not use
1181 * RSA, return an error */
1182 if (OBJ_obj2nid(ri->keyEncryptionAlgorithm) != NID_rsaEncryption) {
1183 retval = CRYPTO_ERROR_INVALID_CRYPTO;
1187 /* Decrypt the session key */
1188 /* Allocate sufficient space for the largest possible decrypted data */
1189 cs->session_key = (unsigned char *) malloc(EVP_PKEY_size(keypair->privkey));
1190 cs->session_key_len = EVP_PKEY_decrypt(cs->session_key, M_ASN1_STRING_data(ri->encryptedKey),
1191 M_ASN1_STRING_length(ri->encryptedKey), keypair->privkey);
1193 if (cs->session_key_len <= 0) {
1194 openssl_post_errors(M_ERROR, _("Failure decrypting the session key"));
1195 retval = CRYPTO_ERROR_DECRYPTION;
1199 /* Session key successfully extracted, return the CRYPTO_SESSION structure */
1201 return CRYPTO_ERROR_NONE;
1206 /* No matching recipient found */
1207 return CRYPTO_ERROR_NORECIPIENT;
1210 crypto_session_free(cs);
1215 * Free memory associated with a crypto session object.
1217 void crypto_session_free (CRYPTO_SESSION *cs)
1219 if (cs->cryptoData) {
1220 CryptoData_free(cs->cryptoData);
1222 if (cs->session_key){
1223 free(cs->session_key);
1229 * Create a new crypto cipher context with the specified session object
1230 * Returns: A pointer to a CIPHER_CONTEXT object on success. The cipher block size is returned in blocksize.
1233 CIPHER_CONTEXT *crypto_cipher_new (CRYPTO_SESSION *cs, bool encrypt, size_t *blocksize)
1235 CIPHER_CONTEXT *cipher_ctx;
1236 const EVP_CIPHER *ec;
1238 cipher_ctx = (CIPHER_CONTEXT *) malloc(sizeof(CIPHER_CONTEXT));
1244 * Acquire a cipher instance for the given ASN.1 cipher NID
1246 if ((ec = EVP_get_cipherbyobj(cs->cryptoData->contentEncryptionAlgorithm)) == NULL) {
1247 Emsg1(M_ERROR, 0, _("Unsupported contentEncryptionAlgorithm: %d\n"), OBJ_obj2nid(cs->cryptoData->contentEncryptionAlgorithm));
1252 /* Initialize the OpenSSL cipher context */
1253 EVP_CIPHER_CTX_init(&cipher_ctx->ctx);
1255 /* Initialize for encryption */
1256 if (!EVP_CipherInit_ex(&cipher_ctx->ctx, ec, NULL, NULL, NULL, 1)) {
1257 openssl_post_errors(M_ERROR, _("OpenSSL cipher context initialization failed"));
1261 /* Initialize for decryption */
1262 if (!EVP_CipherInit_ex(&cipher_ctx->ctx, ec, NULL, NULL, NULL, 0)) {
1263 openssl_post_errors(M_ERROR, _("OpenSSL cipher context initialization failed"));
1268 /* Set the key size */
1269 if (!EVP_CIPHER_CTX_set_key_length(&cipher_ctx->ctx, cs->session_key_len)) {
1270 openssl_post_errors(M_ERROR, _("Encryption session provided an invalid symmetric key"));
1274 /* Validate the IV length */
1275 if (EVP_CIPHER_iv_length(ec) != M_ASN1_STRING_length(cs->cryptoData->iv)) {
1276 openssl_post_errors(M_ERROR, _("Encryption session provided an invalid IV"));
1280 /* Add the key and IV to the cipher context */
1281 if (!EVP_CipherInit_ex(&cipher_ctx->ctx, NULL, NULL, cs->session_key, M_ASN1_STRING_data(cs->cryptoData->iv), -1)) {
1282 openssl_post_errors(M_ERROR, _("OpenSSL cipher context key/IV initialization failed"));
1286 *blocksize = EVP_CIPHER_CTX_block_size(&cipher_ctx->ctx);
1290 crypto_cipher_free(cipher_ctx);
1296 * Encrypt/Decrypt length bytes of data using the provided cipher context
1297 * Returns: true on success, number of bytes output in written
1300 bool crypto_cipher_update(CIPHER_CONTEXT *cipher_ctx, const uint8_t *data, uint32_t length, const uint8_t *dest, uint32_t *written)
1302 if (!EVP_CipherUpdate(&cipher_ctx->ctx, (unsigned char *)dest, (int *)written, (const unsigned char *)data, length)) {
1303 /* This really shouldn't fail */
1311 * Finalize the cipher context, writing any remaining data and necessary padding
1312 * to dest, and the size in written.
1313 * The result size will either be one block of data or zero.
1315 * Returns: true on success
1318 bool crypto_cipher_finalize (CIPHER_CONTEXT *cipher_ctx, void *dest, size_t *written) {
1319 if (!EVP_CipherFinal_ex(&cipher_ctx->ctx, (unsigned char *) dest, (int *) written)) {
1320 /* This really shouldn't fail */
1329 * Free memory associated with a cipher context.
1331 void crypto_cipher_free (CIPHER_CONTEXT *cipher_ctx)
1333 EVP_CIPHER_CTX_cleanup(&cipher_ctx->ctx);
1339 * Perform global initialization of OpenSSL
1340 * This function is not thread safe.
1341 * Returns: 0 on success
1344 int init_crypto (void)
1348 if ((stat = openssl_init_threads()) != 0) {
1349 Emsg1(M_ABORT, 0, _("Unable to init OpenSSL threading: ERR=%s\n"), strerror(stat));
1352 /* Load libssl and libcrypto human-readable error strings */
1353 SSL_load_error_strings();
1355 /* Initialize OpenSSL SSL library */
1358 /* Register OpenSSL ciphers and digests */
1359 OpenSSL_add_all_algorithms();
1361 if (!openssl_seed_prng()) {
1362 Emsg0(M_ERROR_TERM, 0, _("Failed to seed OpenSSL PRNG\n"));
1365 crypto_initialized = true;
1371 * Perform global cleanup of OpenSSL
1372 * All cryptographic operations must be completed before calling this function.
1373 * This function is not thread safe.
1374 * Returns: 0 on success
1377 int cleanup_crypto (void)
1380 * Ensure that we've actually been initialized; Doing this here decreases the
1381 * complexity of client's termination/cleanup code.
1383 if (!crypto_initialized) {
1387 if (!openssl_save_prng()) {
1388 Emsg0(M_ERROR, 0, _("Failed to save OpenSSL PRNG\n"));
1391 openssl_cleanup_threads();
1393 /* Free libssl and libcrypto error strings */
1396 /* Free all ciphers and digests */
1399 /* Free memory used by PRNG */
1402 crypto_initialized = false;
1408 #else /* HAVE_OPENSSL */
1409 # error No encryption library available
1410 #endif /* HAVE_OPENSSL */
1412 #else /* HAVE_CRYPTO */
1415 * Cryptography Support Disabled
1418 /* Message Digest Structure */
1420 crypto_digest_t type;
1427 /* Dummy Signature Structure */
1431 DIGEST *crypto_digest_new (crypto_digest_t type)
1435 digest = (DIGEST *)malloc(sizeof(DIGEST));
1436 digest->type = type;
1439 case CRYPTO_DIGEST_MD5:
1440 MD5Init(&digest->md5);
1442 case CRYPTO_DIGEST_SHA1:
1443 SHA1Init(&digest->sha1);
1446 Emsg0(M_ERROR, 0, _("Unsupported digest type specified\n"));
1454 bool crypto_digest_update(DIGEST *digest, const uint8_t *data, uint32_t length)
1456 switch (digest->type) {
1457 case CRYPTO_DIGEST_MD5:
1458 /* Doesn't return anything ... */
1459 MD5Update(&digest->md5, (unsigned char *) data, length);
1461 case CRYPTO_DIGEST_SHA1:
1463 if ((ret = SHA1Update(&digest->sha1, (const u_int8_t *) data, length)) == shaSuccess) {
1466 Emsg1(M_ERROR, 0, _("SHA1Update() returned an error: %d\n"), ret);
1475 bool crypto_digest_finalize(DIGEST *digest, uint8_t *dest, uint32_t *length)
1477 switch (digest->type) {
1478 case CRYPTO_DIGEST_MD5:
1479 /* Guard against programmer error by either the API client or
1480 * an out-of-sync CRYPTO_DIGEST_MAX_SIZE */
1481 assert(*length >= CRYPTO_DIGEST_MD5_SIZE);
1482 *length = CRYPTO_DIGEST_MD5_SIZE;
1483 /* Doesn't return anything ... */
1484 MD5Final((unsigned char *)dest, &digest->md5);
1486 case CRYPTO_DIGEST_SHA1:
1487 /* Guard against programmer error by either the API client or
1488 * an out-of-sync CRYPTO_DIGEST_MAX_SIZE */
1489 assert(*length >= CRYPTO_DIGEST_SHA1_SIZE);
1490 *length = CRYPTO_DIGEST_SHA1_SIZE;
1491 if (SHA1Final(&digest->sha1, (u_int8_t *) dest) == shaSuccess) {
1504 void crypto_digest_free(DIGEST *digest)
1509 /* Dummy routines */
1510 int init_crypto (void) { return 0; }
1511 int cleanup_crypto (void) { return 0; }
1513 SIGNATURE *crypto_sign_new (void) { return NULL; }
1515 crypto_error_t crypto_sign_get_digest (SIGNATURE *sig, X509_KEYPAIR *keypair, DIGEST **digest) { return CRYPTO_ERROR_INTERNAL; }
1516 crypto_error_t crypto_sign_verify (SIGNATURE *sig, X509_KEYPAIR *keypair, DIGEST *digest) { return CRYPTO_ERROR_INTERNAL; }
1518 int crypto_sign_add_signer (SIGNATURE *sig, DIGEST *digest, X509_KEYPAIR *keypair) { return false; }
1519 int crypto_sign_encode (SIGNATURE *sig, uint8_t *dest, uint32_t *length) { return false; }
1521 SIGNATURE *crypto_sign_decode (const uint8_t *sigData, uint32_t length) { return NULL; }
1522 void crypto_sign_free (SIGNATURE *sig) { }
1525 X509_KEYPAIR *crypto_keypair_new (void) { return NULL; }
1526 X509_KEYPAIR *crypto_keypair_dup (X509_KEYPAIR *keypair) { return NULL; }
1527 int crypto_keypair_load_cert (X509_KEYPAIR *keypair, const char *file) { return false; }
1528 bool crypto_keypair_has_key (const char *file) { return false; }
1529 int crypto_keypair_load_key (X509_KEYPAIR *keypair, const char *file, CRYPTO_PEM_PASSWD_CB *pem_callback, const void *pem_userdata) { return false; }
1530 void crypto_keypair_free (X509_KEYPAIR *keypair) { }
1532 CRYPTO_SESSION *crypto_session_new (crypto_cipher_t cipher, alist *pubkeys) { return NULL; }
1533 void crypto_session_free (CRYPTO_SESSION *cs) { }
1534 bool crypto_session_encode (CRYPTO_SESSION *cs, uint8_t *dest, uint32_t *length) { return false; }
1535 crypto_error_t crypto_session_decode(const uint8_t *data, uint32_t length, alist *keypairs, CRYPTO_SESSION **session) { return CRYPTO_ERROR_INTERNAL; }
1537 CIPHER_CONTEXT *crypto_cipher_new (CRYPTO_SESSION *cs, bool encrypt, uint32_t *blocksize) { return NULL; }
1538 bool crypto_cipher_update (CIPHER_CONTEXT *cipher_ctx, const uint8_t *data, uint32_t length, const uint8_t *dest, uint32_t *written) { return false; }
1539 bool crypto_cipher_finalize (CIPHER_CONTEXT *cipher_ctx, uint8_t *dest, uint32_t *written) { return false; }
1540 void crypto_cipher_free (CIPHER_CONTEXT *cipher_ctx) { }
1542 #endif /* HAVE_CRYPTO */
1547 * Default PEM encryption passphrase callback.
1548 * Returns an empty password.
1550 int crypto_default_pem_callback(char *buf, int size, const void *userdata)
1552 bstrncpy(buf, "", size);
1553 return (strlen(buf));
1557 * Returns the ASCII name of the digest type.
1558 * Returns: ASCII name of digest type.
1560 const char *crypto_digest_name (DIGEST *digest) {
1561 switch (digest->type) {
1562 case CRYPTO_DIGEST_MD5:
1564 case CRYPTO_DIGEST_SHA1:
1566 case CRYPTO_DIGEST_SHA256:
1568 case CRYPTO_DIGEST_SHA512:
1570 case CRYPTO_DIGEST_NONE:
1573 return "Invalid Digest Type";
1579 * Given a stream type, returns the associated
1580 * crypto_digest_t value.
1582 crypto_digest_t crypto_digest_stream_type (int stream) {
1584 case STREAM_MD5_DIGEST:
1585 return CRYPTO_DIGEST_MD5;
1586 case STREAM_SHA1_DIGEST:
1587 return CRYPTO_DIGEST_SHA1;
1588 case STREAM_SHA256_DIGEST:
1589 return CRYPTO_DIGEST_SHA256;
1590 case STREAM_SHA512_DIGEST:
1591 return CRYPTO_DIGEST_SHA512;
1593 return CRYPTO_DIGEST_NONE;
1598 * * Given a crypto_error_t value, return the associated
1601 const char *crypto_strerror(crypto_error_t error) {
1603 case CRYPTO_ERROR_NONE:
1605 case CRYPTO_ERROR_NOSIGNER:
1606 return "Signer not found";
1607 case CRYPTO_ERROR_NORECIPIENT:
1608 return "Recipient not found";
1609 case CRYPTO_ERROR_INVALID_DIGEST:
1610 return "Unsupported digest algorithm";
1611 case CRYPTO_ERROR_INVALID_CRYPTO:
1612 return "Unsupported encryption algorithm";
1613 case CRYPTO_ERROR_BAD_SIGNATURE:
1614 return "Signature is invalid";
1615 case CRYPTO_ERROR_DECRYPTION:
1616 return "Decryption error";
1617 case CRYPTO_ERROR_INTERNAL:
1618 /* This shouldn't happen */
1619 return "Internal error";
1621 return "Unknown error";