1 /*
2 BAREOS® - Backup Archiving REcovery Open Sourced
3
4 Copyright (C) 2005-2011 Free Software Foundation Europe e.V.
5
6 This program is Free Software; you can redistribute it and/or
7 modify it under the terms of version three of the GNU Affero General Public
8 License as published by the Free Software Foundation and included
9 in the file LICENSE.
10
11 This program is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Affero General Public License for more details.
15
16 You should have received a copy of the GNU Affero General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
19 02110-1301, USA.
20 */
21 /*
22 * crypto_none.c Encryption support functions when no backend.
23 *
24 * Author: Landon Fuller <landonf@opendarwin.org>
25 */
26
27 #include "include/bareos.h"
28
29 #if !defined(HAVE_OPENSSL)
30
31 #include "jcr.h"
32 #include <assert.h>
33
34 /* Message Digest Structure */
35 struct Digest {
36 crypto_digest_t type;
37 JobControlRecord *jcr;
38 union {
39 SHA1_CTX sha1;
40 MD5_CTX md5;
41 };
42 };
43
44 /* Dummy Signature Structure */
45 struct Signature {
46 JobControlRecord *jcr;
47 };
48
crypto_digest_new(JobControlRecord * jcr,crypto_digest_t type)49 DIGEST *crypto_digest_new(JobControlRecord *jcr, crypto_digest_t type)
50 {
51 DIGEST *digest;
52
53 digest = (DIGEST *)malloc(sizeof(DIGEST));
54 digest->type = type;
55 digest->jcr = jcr;
56
57 switch (type) {
58 case CRYPTO_DIGEST_MD5:
59 MD5_Init(&digest->md5);
60 break;
61 case CRYPTO_DIGEST_SHA1:
62 SHA1Init(&digest->sha1);
63 break;
64 default:
65 Jmsg1(jcr, M_ERROR, 0, _("Unsupported digest type=%d specified\n"), type);
66 free(digest);
67 return NULL;
68 }
69
70 return (digest);
71 }
72
CryptoDigestUpdate(DIGEST * digest,const uint8_t * data,uint32_t length)73 bool CryptoDigestUpdate(DIGEST *digest, const uint8_t *data, uint32_t length)
74 {
75 switch (digest->type) {
76 case CRYPTO_DIGEST_MD5:
77 /* Doesn't return anything ... */
78 MD5_Update(&digest->md5, (unsigned char *) data, length);
79 return true;
80 case CRYPTO_DIGEST_SHA1:
81 /* Doesn't return anything ... */
82 SHA1Update(&digest->sha1, (const u_int8_t *) data, (unsigned int)length);
83 return true;
84 default:
85 return false;
86 }
87 }
88
CryptoDigestFinalize(DIGEST * digest,uint8_t * dest,uint32_t * length)89 bool CryptoDigestFinalize(DIGEST *digest, uint8_t *dest, uint32_t *length)
90 {
91 switch (digest->type) {
92 case CRYPTO_DIGEST_MD5:
93 /* Guard against programmer error by either the API client or
94 * an out-of-sync CRYPTO_DIGEST_MAX_SIZE */
95 assert(*length >= CRYPTO_DIGEST_MD5_SIZE);
96 *length = CRYPTO_DIGEST_MD5_SIZE;
97 /* Doesn't return anything ... */
98 MD5_Final((unsigned char *)dest, &digest->md5);
99 return true;
100 case CRYPTO_DIGEST_SHA1:
101 /* Guard against programmer error by either the API client or
102 * an out-of-sync CRYPTO_DIGEST_MAX_SIZE */
103 assert(*length >= CRYPTO_DIGEST_SHA1_SIZE);
104 *length = CRYPTO_DIGEST_SHA1_SIZE;
105 SHA1Final((u_int8_t *) dest, &digest->sha1);
106 return true;
107 default:
108 return false;
109 }
110
111 return false;
112 }
113
CryptoDigestFree(DIGEST * digest)114 void CryptoDigestFree(DIGEST *digest)
115 {
116 free(digest);
117 }
118
crypto_sign_new(JobControlRecord * jcr)119 SIGNATURE *crypto_sign_new(JobControlRecord *jcr)
120 {
121 return NULL;
122 }
123
CryptoSignGetDigest(SIGNATURE * sig,X509_KEYPAIR * keypair,crypto_digest_t & type,DIGEST ** digest)124 crypto_error_t CryptoSignGetDigest(SIGNATURE *sig, X509_KEYPAIR *keypair,
125 crypto_digest_t &type, DIGEST **digest)
126 {
127 return CRYPTO_ERROR_INTERNAL;
128 }
129
CryptoSignVerify(SIGNATURE * sig,X509_KEYPAIR * keypair,DIGEST * digest)130 crypto_error_t CryptoSignVerify(SIGNATURE *sig, X509_KEYPAIR *keypair, DIGEST *digest)
131 {
132 return CRYPTO_ERROR_INTERNAL;
133 }
134
CryptoSignAddSigner(SIGNATURE * sig,DIGEST * digest,X509_KEYPAIR * keypair)135 int CryptoSignAddSigner(SIGNATURE *sig, DIGEST *digest, X509_KEYPAIR *keypair)
136 {
137 return false;
138 }
139
CryptoSignEncode(SIGNATURE * sig,uint8_t * dest,uint32_t * length)140 int CryptoSignEncode(SIGNATURE *sig, uint8_t *dest, uint32_t *length)
141 {
142 return false;
143 }
144
crypto_sign_decode(JobControlRecord * jcr,const uint8_t * sigData,uint32_t length)145 SIGNATURE *crypto_sign_decode(JobControlRecord *jcr, const uint8_t *sigData, uint32_t length)
146 {
147 return NULL;
148 }
149
CryptoSignFree(SIGNATURE * sig)150 void CryptoSignFree(SIGNATURE *sig)
151 {
152 }
153
crypto_keypair_new(void)154 X509_KEYPAIR *crypto_keypair_new(void)
155 {
156 return NULL;
157 }
158
crypto_keypair_dup(X509_KEYPAIR * keypair)159 X509_KEYPAIR *crypto_keypair_dup(X509_KEYPAIR *keypair)
160 {
161 return NULL;
162 }
163
CryptoKeypairLoadCert(X509_KEYPAIR * keypair,const char * file)164 int CryptoKeypairLoadCert(X509_KEYPAIR *keypair, const char *file)
165 {
166 return false;
167 }
168
CryptoKeypairHasKey(const char * file)169 bool CryptoKeypairHasKey(const char *file)
170 {
171 return false;
172 }
173
CryptoKeypairLoadKey(X509_KEYPAIR * keypair,const char * file,CRYPTO_PEM_PASSWD_CB * pem_callback,const void * pem_userdata)174 int CryptoKeypairLoadKey(X509_KEYPAIR *keypair, const char *file, CRYPTO_PEM_PASSWD_CB *pem_callback, const void *pem_userdata)
175 {
176 return false;
177 }
178
CryptoKeypairFree(X509_KEYPAIR * keypair)179 void CryptoKeypairFree(X509_KEYPAIR *keypair)
180 {
181 }
182
crypto_session_new(crypto_cipher_t cipher,alist * pubkeys)183 CRYPTO_SESSION *crypto_session_new(crypto_cipher_t cipher, alist *pubkeys)
184 {
185 return NULL;
186 }
187
CryptoSessionFree(CRYPTO_SESSION * cs)188 void CryptoSessionFree(CRYPTO_SESSION *cs)
189 {
190 }
191
CryptoSessionEncode(CRYPTO_SESSION * cs,uint8_t * dest,uint32_t * length)192 bool CryptoSessionEncode(CRYPTO_SESSION *cs, uint8_t *dest, uint32_t *length)
193 {
194 return false;
195 }
196
CryptoSessionDecode(const uint8_t * data,uint32_t length,alist * keypairs,CRYPTO_SESSION ** session)197 crypto_error_t CryptoSessionDecode(const uint8_t *data, uint32_t length, alist *keypairs, CRYPTO_SESSION **session)
198 {
199 return CRYPTO_ERROR_INTERNAL;
200 }
201
crypto_cipher_new(CRYPTO_SESSION * cs,bool encrypt,uint32_t * blocksize)202 CIPHER_CONTEXT *crypto_cipher_new(CRYPTO_SESSION *cs, bool encrypt, uint32_t *blocksize)
203 {
204 return NULL;
205 }
206
CryptoCipherUpdate(CIPHER_CONTEXT * cipher_ctx,const uint8_t * data,uint32_t length,const uint8_t * dest,uint32_t * written)207 bool CryptoCipherUpdate(CIPHER_CONTEXT *cipher_ctx, const uint8_t *data, uint32_t length, const uint8_t *dest, uint32_t *written)
208 {
209 return false;
210 }
211
CryptoCipherFinalize(CIPHER_CONTEXT * cipher_ctx,uint8_t * dest,uint32_t * written)212 bool CryptoCipherFinalize(CIPHER_CONTEXT *cipher_ctx, uint8_t *dest, uint32_t *written)
213 {
214 return false;
215 }
216
CryptoCipherFree(CIPHER_CONTEXT * cipher_ctx)217 void CryptoCipherFree(CIPHER_CONTEXT *cipher_ctx)
218 {
219 }
220
crypto_digest_name(DIGEST * digest)221 const char *crypto_digest_name(DIGEST *digest)
222 {
223 return crypto_digest_name(digest->type);
224 }
225 #endif /* HAVE_CRYPTO */
226
227 #if !defined(HAVE_OPENSSL) && \
228 !defined(HAVE_NSS)
229 /*
230 * Dummy initialization functions when no crypto framework found.
231 */
InitCrypto(void)232 int InitCrypto(void)
233 {
234 return 0;
235 }
236
CleanupCrypto(void)237 int CleanupCrypto(void)
238 {
239 return 0;
240 }
241 #endif /* !HAVE_OPENSSL && !HAVE_NSS */
242