Mercurial > hg > dav / file comparison

comparison: dav/crypto.c

dav/crypto.c

changeset 10
e6d0fbe0ebd9
parent 9
6aec77cfa95b
child 11
5db6178d8b58
equal deleted inserted replaced
9:6aec77cfa95b 10:e6d0fbe0ebd9
27 */ 27 */
28 28
29 #include <stdio.h> 29 #include <stdio.h>
30 #include <stdlib.h> 30 #include <stdlib.h>
31 #include <string.h> 31 #include <string.h>
32 #include <openssl/rand.h>
32 33
33 #include "crypto.h" 34 #include "crypto.h"
34 35
35 AESDecrypter* aes_decrypter_new(Key *key, void *stream, dav_write_func write_func) { 36 AESDecrypter* aes_decrypter_new(Key *key, void *stream, dav_write_func write_func) {
36 AESDecrypter *dec = malloc(sizeof(AESDecrypter)); 37 AESDecrypter *dec = malloc(sizeof(AESDecrypter));
37 dec->stream = stream; 38 dec->stream = stream;
38 dec->write = write_func; 39 dec->write = write_func;
40 dec->key = key;
41 dec->init = 0;
42 dec->ivpos = 0;
39 43
44 return dec;
45 }
46
47 void aes_decrypter_init(AESDecrypter *dec) {
40 EVP_CIPHER_CTX_init(&dec->ctx); 48 EVP_CIPHER_CTX_init(&dec->ctx);
41 if(key->type == KEY_AES128) { 49 dec->init = 1;
42 EVP_DecryptInit_ex(&dec->ctx, EVP_aes_128_cbc(), NULL, key->data, NULL); 50 if(dec->key->type == KEY_AES128) {
43 } else if(key->type == KEY_AES256) { 51 EVP_DecryptInit_ex(
44 EVP_DecryptInit_ex(&dec->ctx, EVP_aes_256_cbc(), NULL, key->data, NULL); 52 &dec->ctx,
53 EVP_aes_128_cbc(),
54 NULL,
55 dec->key->data,
56 dec->ivtmp);
57 } else if(dec->key->type == KEY_AES256) {
58 EVP_DecryptInit_ex(
59 &dec->ctx,
60 EVP_aes_256_cbc(),
61 NULL,
62 dec->key->data,
63 dec->ivtmp);
45 } else { 64 } else {
46 fprintf(stderr, "unknown key type\n"); 65 fprintf(stderr, "unknown key type\n");
47 exit(-1); 66 exit(-1);
48 } 67 }
49 return dec;
50 } 68 }
51 69
52 size_t aes_write(const void *buf, size_t s, size_t n, AESDecrypter *dec) { 70 size_t aes_write(const void *buf, size_t s, size_t n, AESDecrypter *dec) {
53 int len = s*n; 71 int len = s*n;
72 if(!dec->init) {
73 size_t n = 16 - dec->ivpos;
74 size_t cp = n > len ? len : n;
75 memcpy(dec->ivtmp + dec->ivpos, buf, cp);
76 dec->ivpos += cp;
77 if(dec->ivpos >= 16) {
78 aes_decrypter_init(dec);
79 }
80 if(len == cp) {
81 return len;
82 } else {
83 buf = (char*)buf + cp;
84 len -= cp;
85 }
86 }
87
54 int outlen = len + 16; 88 int outlen = len + 16;
55 unsigned char *out = malloc(outlen); 89 unsigned char *out = malloc(outlen);
56 EVP_DecryptUpdate(&dec->ctx, out, &len, buf, len); 90 EVP_DecryptUpdate(&dec->ctx, out, &len, buf, len);
57 dec->write(out, 1, len, dec->stream); 91 dec->write(out, 1, len, dec->stream);
58 free(out); 92 free(out);
69 free(dec); 103 free(dec);
70 } 104 }
71 105
72 106
73 AESEncrypter* aes_encrypter_new(Key *key, void *stream, dav_read_func read_func) { 107 AESEncrypter* aes_encrypter_new(Key *key, void *stream, dav_read_func read_func) {
108 unsigned char *iv = malloc(16);
109 if(!RAND_bytes(iv, 16)) {
110 free(iv);
111 return NULL;
112 }
113
74 AESEncrypter *enc = malloc(sizeof(AESEncrypter)); 114 AESEncrypter *enc = malloc(sizeof(AESEncrypter));
75 enc->stream = stream; 115 enc->stream = stream;
76 enc->read = read_func; 116 enc->read = read_func;
77 enc->tmp = NULL; 117 enc->tmp = NULL;
78 enc->tmplen = 0; 118 enc->tmplen = 0;
79 enc->tmpoff = 0; 119 enc->tmpoff = 0;
80 enc->end = 0; 120 enc->end = 0;
121 //enc->iv = iv;
122 enc->iv = iv;
123 enc->ivlen = 16;
81 124
82 EVP_CIPHER_CTX_init(&enc->ctx); 125 EVP_CIPHER_CTX_init(&enc->ctx);
83 if(key->type == KEY_AES128) { 126 if(key->type == KEY_AES128) {
84 EVP_EncryptInit_ex(&enc->ctx, EVP_aes_128_cbc(), NULL, key->data, NULL); 127 EVP_EncryptInit_ex(&enc->ctx, EVP_aes_128_cbc(), NULL, key->data, enc->iv);
85 } else if(key->type == KEY_AES256) { 128 } else if(key->type == KEY_AES256) {
86 EVP_EncryptInit_ex(&enc->ctx, EVP_aes_256_cbc(), NULL, key->data, NULL); 129 EVP_EncryptInit_ex(&enc->ctx, EVP_aes_256_cbc(), NULL, key->data, enc->iv);
87 } else { 130 } else {
88 fprintf(stderr, "unknown key type\n"); 131 fprintf(stderr, "unknown key type\n");
89 exit(-1); 132 exit(-1);
90 } 133 }
91 return enc; 134 return enc;
112 } 155 }
113 156
114 void *in = malloc(len); 157 void *in = malloc(len);
115 size_t in_len = enc->read(in, 1, len, enc->stream); 158 size_t in_len = enc->read(in, 1, len, enc->stream);
116 159
117 void *out = NULL; 160 unsigned char *out = NULL;
118 int outlen = 0; 161 int outlen = 0;
162 size_t ivl = enc->ivlen;
119 if(in_len != 0) { 163 if(in_len != 0) {
120 outlen = len + 16; 164 outlen = len + 16;
121 out = malloc(outlen); 165 out = malloc(outlen + ivl);
122 EVP_EncryptUpdate(&enc->ctx, out, &outlen, in, in_len); 166 if(enc->iv) {
123 //out = (char*)aes_encrypt(enc->ctx, (unsigned char*)in, (int*)&in_len); 167 memcpy(out, enc->iv, ivl);
168 }
169 EVP_EncryptUpdate(&enc->ctx, out + ivl, &outlen, in, in_len);
124 } else { 170 } else {
125 out = malloc(16); 171 out = malloc(16);
126 EVP_EncryptFinal_ex(&enc->ctx, out, &outlen); 172 EVP_EncryptFinal_ex(&enc->ctx, out, &outlen);
127 enc->end = 1; 173 enc->end = 1;
128 } 174 }
129 enc->tmp = out; 175 enc->tmp = (char*)out;
130 enc->tmplen = outlen; 176 enc->tmplen = outlen + ivl;
131 enc->tmpoff = 0; 177 enc->tmpoff = 0;
178
179 if(enc->iv) {
180 enc->iv = NULL;
181 enc->ivlen = 0;
182 }
132 183
133 return aes_read(buf, s, n, enc); 184 return aes_read(buf, s, n, enc);
134 } 185 }
135 186
136 void aes_encrypter_close(AESEncrypter *enc) { 187 void aes_encrypter_close(AESEncrypter *enc) {

Mercurial Repository: dav

mercurial