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) { free(digest); }
115
crypto_sign_new(JobControlRecord * jcr)116 SIGNATURE* crypto_sign_new(JobControlRecord* jcr) { return NULL; }
117
CryptoSignGetDigest(SIGNATURE * sig,X509_KEYPAIR * keypair,crypto_digest_t & type,DIGEST ** digest)118 crypto_error_t CryptoSignGetDigest(SIGNATURE* sig,
119 X509_KEYPAIR* keypair,
120 crypto_digest_t& type,
121 DIGEST** digest)
122 {
123 return CRYPTO_ERROR_INTERNAL;
124 }
125
CryptoSignVerify(SIGNATURE * sig,X509_KEYPAIR * keypair,DIGEST * digest)126 crypto_error_t CryptoSignVerify(SIGNATURE* sig,
127 X509_KEYPAIR* keypair,
128 DIGEST* digest)
129 {
130 return CRYPTO_ERROR_INTERNAL;
131 }
132
CryptoSignAddSigner(SIGNATURE * sig,DIGEST * digest,X509_KEYPAIR * keypair)133 int CryptoSignAddSigner(SIGNATURE* sig, DIGEST* digest, X509_KEYPAIR* keypair)
134 {
135 return false;
136 }
137
CryptoSignEncode(SIGNATURE * sig,uint8_t * dest,uint32_t * length)138 int CryptoSignEncode(SIGNATURE* sig, uint8_t* dest, uint32_t* length)
139 {
140 return false;
141 }
142
crypto_sign_decode(JobControlRecord * jcr,const uint8_t * sigData,uint32_t length)143 SIGNATURE* crypto_sign_decode(JobControlRecord* jcr,
144 const uint8_t* sigData,
145 uint32_t length)
146 {
147 return NULL;
148 }
149
CryptoSignFree(SIGNATURE * sig)150 void CryptoSignFree(SIGNATURE* sig) {}
151
crypto_keypair_new(void)152 X509_KEYPAIR* crypto_keypair_new(void) { return NULL; }
153
crypto_keypair_dup(X509_KEYPAIR * keypair)154 X509_KEYPAIR* crypto_keypair_dup(X509_KEYPAIR* keypair) { return NULL; }
155
CryptoKeypairLoadCert(X509_KEYPAIR * keypair,const char * file)156 int CryptoKeypairLoadCert(X509_KEYPAIR* keypair, const char* file)
157 {
158 return false;
159 }
160
CryptoKeypairHasKey(const char * file)161 bool CryptoKeypairHasKey(const char* file) { return false; }
162
CryptoKeypairLoadKey(X509_KEYPAIR * keypair,const char * file,CRYPTO_PEM_PASSWD_CB * pem_callback,const void * pem_userdata)163 int CryptoKeypairLoadKey(X509_KEYPAIR* keypair,
164 const char* file,
165 CRYPTO_PEM_PASSWD_CB* pem_callback,
166 const void* pem_userdata)
167 {
168 return false;
169 }
170
CryptoKeypairFree(X509_KEYPAIR * keypair)171 void CryptoKeypairFree(X509_KEYPAIR* keypair) {}
172
crypto_session_new(crypto_cipher_t cipher,alist * pubkeys)173 CRYPTO_SESSION* crypto_session_new(crypto_cipher_t cipher, alist* pubkeys)
174 {
175 return NULL;
176 }
177
CryptoSessionFree(CRYPTO_SESSION * cs)178 void CryptoSessionFree(CRYPTO_SESSION* cs) {}
179
CryptoSessionEncode(CRYPTO_SESSION * cs,uint8_t * dest,uint32_t * length)180 bool CryptoSessionEncode(CRYPTO_SESSION* cs, uint8_t* dest, uint32_t* length)
181 {
182 return false;
183 }
184
CryptoSessionDecode(const uint8_t * data,uint32_t length,alist * keypairs,CRYPTO_SESSION ** session)185 crypto_error_t CryptoSessionDecode(const uint8_t* data,
186 uint32_t length,
187 alist* keypairs,
188 CRYPTO_SESSION** session)
189 {
190 return CRYPTO_ERROR_INTERNAL;
191 }
192
crypto_cipher_new(CRYPTO_SESSION * cs,bool encrypt,uint32_t * blocksize)193 CIPHER_CONTEXT* crypto_cipher_new(CRYPTO_SESSION* cs,
194 bool encrypt,
195 uint32_t* blocksize)
196 {
197 return NULL;
198 }
199
CryptoCipherUpdate(CIPHER_CONTEXT * cipher_ctx,const uint8_t * data,uint32_t length,const uint8_t * dest,uint32_t * written)200 bool CryptoCipherUpdate(CIPHER_CONTEXT* cipher_ctx,
201 const uint8_t* data,
202 uint32_t length,
203 const uint8_t* dest,
204 uint32_t* written)
205 {
206 return false;
207 }
208
CryptoCipherFinalize(CIPHER_CONTEXT * cipher_ctx,uint8_t * dest,uint32_t * written)209 bool CryptoCipherFinalize(CIPHER_CONTEXT* cipher_ctx,
210 uint8_t* dest,
211 uint32_t* written)
212 {
213 return false;
214 }
215
CryptoCipherFree(CIPHER_CONTEXT * cipher_ctx)216 void CryptoCipherFree(CIPHER_CONTEXT* cipher_ctx) {}
217
crypto_digest_name(DIGEST * digest)218 const char* crypto_digest_name(DIGEST* digest)
219 {
220 return crypto_digest_name(digest->type);
221 }
222 #endif /* HAVE_CRYPTO */
223
224 #if !defined(HAVE_OPENSSL) && !defined(HAVE_NSS)
225 /*
226 * Dummy initialization functions when no crypto framework found.
227 */
InitCrypto(void)228 int InitCrypto(void) { return 0; }
229
CleanupCrypto(void)230 int CleanupCrypto(void) { return 0; }
231 #endif /* !HAVE_OPENSSL && !HAVE_NSS */
232