Line data Source code
1 : #include "../burp.h"
2 : #include "../alloc.h"
3 : #include "../asfd.h"
4 : #include "../async.h"
5 : #include "../cmd.h"
6 : #include "../cntr.h"
7 : #include "../iobuf.h"
8 : #include "../log.h"
9 : #include "../prepend.h"
10 : #include "../sbuf.h"
11 : #include "handy.h"
12 : #include "msg.h"
13 :
14 4 : static int do_write(struct asfd *asfd,
15 : struct BFILE *bfd, uint8_t *out, size_t outlen,
16 : char **metadata, uint64_t *sent)
17 : {
18 4 : int ret=0;
19 4 : if(metadata)
20 : {
21 : // Append it to our metadata.
22 0 : out[outlen]='\0';
23 : //printf("\nadd outlen: %lu\n", outlen);
24 0 : if(!(*metadata=prepend_len(*metadata, *sent,
25 : (const char *)out, outlen,
26 : "", 0, (size_t *)sent)))
27 : {
28 0 : logp("error when appending metadata\n");
29 0 : asfd->write_str(asfd, CMD_ERROR,
30 : "error when appending metadata");
31 0 : return -1;
32 : }
33 : }
34 : else
35 : {
36 4 : if((ret=bfd->write(bfd, out, outlen))<=0)
37 : {
38 0 : logp("error when appending %lu: %d\n",
39 : (unsigned long)outlen, ret);
40 0 : asfd->write_str(asfd, CMD_ERROR, "write failed");
41 0 : return -1;
42 : }
43 4 : *sent+=outlen;
44 : }
45 : return 0;
46 : }
47 :
48 4 : static int do_inflate(struct asfd *asfd,
49 : z_stream *zstrm, struct BFILE *bfd,
50 : uint8_t *out, uint8_t *buftouse, size_t lentouse,
51 : char **metadata, const char *encpassword, int enccompressed,
52 : uint64_t *sent)
53 : {
54 4 : int zret=Z_OK;
55 4 : unsigned have=0;
56 :
57 : // Do not want to inflate encrypted data that was not compressed.
58 : // Just write it straight out.
59 4 : if(encpassword && !enccompressed)
60 0 : return do_write(asfd, bfd, buftouse, lentouse, metadata, sent);
61 :
62 4 : zstrm->avail_in=lentouse;
63 4 : zstrm->next_in=buftouse;
64 :
65 : do
66 : {
67 4 : zstrm->avail_out=ZCHUNK;
68 4 : zstrm->next_out=out;
69 4 : zret=inflate(zstrm, Z_NO_FLUSH);
70 4 : switch(zret)
71 : {
72 : case Z_NEED_DICT:
73 0 : zret=Z_DATA_ERROR;
74 : case Z_DATA_ERROR:
75 : case Z_MEM_ERROR:
76 0 : logp("zstrm inflate error: %d\n", zret);
77 0 : return -1;
78 : break;
79 : }
80 4 : have=ZCHUNK-zstrm->avail_out;
81 4 : if(!have) continue;
82 :
83 4 : if(do_write(asfd, bfd, out, have, metadata, sent))
84 : return -1;
85 : /*
86 : if(md5)
87 : {
88 : if(!MD5_Update(md5, out, have))
89 : {
90 : logp("MD5 update error\n");
91 : return -1;
92 : }
93 : }
94 : */
95 4 : } while(!zstrm->avail_out);
96 : return 0;
97 : }
98 :
99 : #ifdef HAVE_WIN32
100 :
101 : struct winbuf
102 : {
103 : uint64_t *rcvd;
104 : uint64_t *sent;
105 : struct cntr *cntr;
106 : struct asfd *asfd;
107 : };
108 :
109 : static DWORD WINAPI read_efs(PBYTE pbData, PVOID pvCallbackContext, PULONG ulLength)
110 : {
111 : struct iobuf *rbuf;
112 : struct winbuf *mybuf=(struct winbuf *)pvCallbackContext;
113 : rbuf=mybuf->asfd->rbuf;
114 :
115 : while(1)
116 : {
117 : if(mybuf->asfd->read(mybuf->asfd))
118 : return ERROR_FUNCTION_FAILED;
119 : (*(mybuf->rcvd))+=rbuf->len;
120 :
121 : switch(rbuf->cmd)
122 : {
123 : case CMD_APPEND:
124 : memcpy(pbData, rbuf->buf, rbuf->len);
125 : *ulLength=(ULONG)rbuf->len;
126 : (*(mybuf->sent))+=rbuf->len;
127 : iobuf_free_content(rbuf);
128 : return ERROR_SUCCESS;
129 : case CMD_END_FILE:
130 : *ulLength=0;
131 : iobuf_free_content(rbuf);
132 : return ERROR_SUCCESS;
133 : case CMD_MESSAGE:
134 : logp("MESSAGE: %s\n", rbuf->buf);
135 : cntr_add(mybuf->cntr, rbuf->cmd, 0);
136 : iobuf_free_content(rbuf);
137 : continue;
138 : case CMD_WARNING:
139 : logp("WARNING: %s\n", rbuf->buf);
140 : cntr_add(mybuf->cntr, rbuf->cmd, 0);
141 : iobuf_free_content(rbuf);
142 : continue;
143 : default:
144 : iobuf_log_unexpected(rbuf, __func__);
145 : iobuf_free_content(rbuf);
146 : break;
147 : }
148 : }
149 : return ERROR_FUNCTION_FAILED;
150 : }
151 :
152 : static int transfer_efs_in(struct asfd *asfd,
153 : struct BFILE *bfd, uint64_t *rcvd,
154 : uint64_t *sent, struct cntr *cntr)
155 : {
156 : int ret=0;
157 : struct winbuf mybuf;
158 : mybuf.rcvd=rcvd;
159 : mybuf.sent=sent;
160 : mybuf.cntr=cntr;
161 : mybuf.asfd=asfd;
162 : if((ret=WriteEncryptedFileRaw((PFE_IMPORT_FUNC)read_efs,
163 : &mybuf, bfd->pvContext)))
164 : logp("WriteEncryptedFileRaw returned %d\n", ret);
165 : return ret;
166 : }
167 :
168 : #endif
169 :
170 4 : int transfer_gzfile_inl(struct asfd *asfd,
171 : #ifdef HAVE_WIN32
172 : struct sbuf *sb,
173 : #endif
174 : struct BFILE *bfd,
175 : uint64_t *rcvd, uint64_t *sent,
176 : const char *encpassword, int enccompressed,
177 : struct cntr *cntr, char **metadata)
178 : {
179 4 : int quit=0;
180 4 : int ret=-1;
181 : uint8_t out[ZCHUNK];
182 4 : int doutlen=0;
183 : //uint8_t doutbuf[1000+EVP_MAX_BLOCK_LENGTH];
184 : uint8_t doutbuf[ZCHUNK-EVP_MAX_BLOCK_LENGTH];
185 4 : struct iobuf *rbuf=asfd->rbuf;
186 :
187 : z_stream zstrm;
188 :
189 4 : EVP_CIPHER_CTX *enc_ctx=NULL;
190 :
191 : // Checksum stuff
192 : //MD5_CTX md5;
193 : //uint8_t checksum[MD5_DIGEST_LENGTH];
194 :
195 : #ifdef HAVE_WIN32
196 : if(sb && sb->path.cmd==CMD_EFS_FILE)
197 : return transfer_efs_in(asfd, bfd, rcvd, sent, cntr);
198 : #endif
199 :
200 : //if(!MD5_Init(&md5))
201 : //{
202 : // logp("MD5_Init() failed");
203 : // return -1;
204 : //}
205 :
206 4 : zstrm.zalloc=Z_NULL;
207 4 : zstrm.zfree=Z_NULL;
208 4 : zstrm.opaque=Z_NULL;
209 4 : zstrm.avail_in=0;
210 4 : zstrm.next_in=Z_NULL;
211 :
212 4 : if(inflateInit2(&zstrm, (15+16)))
213 : {
214 0 : logp("unable to init inflate\n");
215 0 : return -1;
216 : }
217 :
218 4 : if(encpassword && !(enc_ctx=enc_setup(0, encpassword)))
219 : {
220 0 : inflateEnd(&zstrm);
221 0 : return -1;
222 : }
223 :
224 12 : while(!quit)
225 : {
226 8 : iobuf_free_content(rbuf);
227 8 : if(asfd->read(asfd))
228 : {
229 0 : if(enc_ctx)
230 : {
231 0 : EVP_CIPHER_CTX_cleanup(enc_ctx);
232 0 : EVP_CIPHER_CTX_free(enc_ctx);
233 0 : enc_ctx=NULL;
234 : }
235 0 : inflateEnd(&zstrm);
236 0 : return -1;
237 : }
238 8 : (*rcvd)+=rbuf->len;
239 :
240 : //logp("transfer in: %c:%s\n", rbuf->cmd, rbuf->buf);
241 8 : switch(rbuf->cmd)
242 : {
243 : case CMD_APPEND: // append
244 4 : if(!bfd && !metadata)
245 : {
246 0 : logp("given append, but no file or metadata to write to\n");
247 0 : asfd->write_str(asfd, CMD_ERROR,
248 : "append with no file or metadata");
249 0 : quit++; ret=-1;
250 : }
251 : else
252 : {
253 : size_t lentouse;
254 4 : uint8_t *buftouse=NULL;
255 : /*
256 : if(!MD5_Update(&md5, rbuf->buf, rbuf->len))
257 : {
258 : logp("MD5 update enc error\n");
259 : quit++; ret=-1;
260 : break;
261 : }
262 : */
263 : // If doing decryption, it needs
264 : // to be done before uncompressing.
265 4 : if(enc_ctx)
266 : {
267 : // updating our checksum needs to
268 : // be done first
269 : /*
270 : if(!MD5_Update(&md5, rbuf->buf, rbuf->len))
271 : {
272 : logp("MD5 update enc error\n");
273 : quit++; ret=-1;
274 : break;
275 : }
276 : else
277 : */
278 0 : if(!EVP_CipherUpdate(enc_ctx,
279 : doutbuf, &doutlen,
280 0 : (uint8_t *)rbuf->buf,
281 0 : rbuf->len))
282 : {
283 0 : logp("Decryption error\n");
284 0 : quit++; ret=-1;
285 0 : break;
286 : }
287 0 : if(!doutlen) break;
288 0 : lentouse=(size_t)doutlen;
289 0 : buftouse=doutbuf;
290 : }
291 : else
292 : {
293 4 : lentouse=rbuf->len;
294 4 : buftouse=(uint8_t *)rbuf->buf;
295 : }
296 : //logp("want to write: %d\n", zstrm.avail_in);
297 :
298 4 : if(do_inflate(asfd, &zstrm, bfd, out,
299 : buftouse, lentouse, metadata,
300 : encpassword,
301 : enccompressed,
302 : sent))
303 : {
304 0 : ret=-1; quit++;
305 0 : break;
306 : }
307 : }
308 : break;
309 : case CMD_END_FILE: // finish up
310 4 : if(enc_ctx)
311 : {
312 0 : if(!EVP_CipherFinal_ex(enc_ctx,
313 : doutbuf, &doutlen))
314 : {
315 0 : logp("Decryption failure at the end.\n");
316 0 : ret=-1; quit++;
317 0 : break;
318 : }
319 0 : if(doutlen && do_inflate(asfd,
320 : &zstrm, bfd,
321 : out, doutbuf, (size_t)doutlen,
322 : metadata, encpassword,
323 : enccompressed, sent))
324 : {
325 0 : ret=-1; quit++;
326 0 : break;
327 : }
328 : }
329 : /*
330 : if(MD5_Final(checksum, &md5))
331 : {
332 : char *oldsum=NULL;
333 : const char *newsum=NULL;
334 :
335 : if((oldsum=strchr(buf, ':')))
336 : {
337 : oldsum++;
338 : newsum=bytes_to_md5str(checksum);
339 : // log if the checksum differed
340 : if(strcmp(newsum, oldsum))
341 : logw(asfd, cntr, "md5sum for '%s' did not match! (%s!=%s)\n", path, newsum, oldsum);
342 : }
343 : }
344 : else
345 : {
346 : logp("MD5_Final() failed\n");
347 : }
348 : */
349 4 : quit++;
350 4 : ret=0;
351 4 : break;
352 : case CMD_MESSAGE:
353 : case CMD_WARNING:
354 0 : log_recvd(rbuf, cntr, 0);
355 0 : break;
356 : default:
357 0 : iobuf_log_unexpected(rbuf, __func__);
358 0 : quit++;
359 0 : ret=-1;
360 0 : break;
361 : }
362 : }
363 4 : inflateEnd(&zstrm);
364 4 : if(enc_ctx)
365 : {
366 0 : EVP_CIPHER_CTX_cleanup(enc_ctx);
367 0 : EVP_CIPHER_CTX_free(enc_ctx);
368 0 : enc_ctx=NULL;
369 : }
370 :
371 4 : iobuf_free_content(rbuf);
372 4 : if(ret) logp("transfer file returning: %d\n", ret);
373 4 : return ret;
374 : }
|
