dav: comparison test/crypto.c

-:26541c37b619
+:42cdbf9bbd49
 keys128[i].type = DAV_KEY_AES128;
 keys128[i].data = data[i];
 }
 }
-CX_TEST(test_util_decrypt_str_k) {
+UCX_TEST(test_util_decrypt_str_k) {
 create_keys();
 DavContext *ctx = dav_context_new();
 DavSession *sn = dav_session_new(ctx, "http://localhost/");
-CX_TEST_DO {
+UCX_TEST_BEGIN;
-for(int k=0;k<2;k++) {
-for(int i=0;i<20;i++) {
+for(int k=0;k<2;k++) {
-char *c1;
+for(int i=0;i<20;i++) {
-char *c2;
+char *c1;
-if(k == 0) {
+char *c2;
-c1 = cryptkey0aes128strings[i];
+if(k == 0) {
-c2 = cryptkey0aes256strings[i];
+c1 = cryptkey0aes128strings[i];
-} else {
+c2 = cryptkey0aes256strings[i];
-c1 = cryptkey1aes128strings[i];
+} else {
-c2 = cryptkey1aes256strings[i];
+c1 = cryptkey1aes128strings[i];
-}
+c2 = cryptkey1aes256strings[i];
-char *s128 = util_decrypt_str_k(sn, c1, &keys128[k]);
-char *s256 = util_decrypt_str_k(sn, c2, &keys256[k]);
-CX_TEST_ASSERT(!strcmp(s128, strings[i]));
-CX_TEST_ASSERT(!strcmp(s256, strings[i]));
 }
+char *s128 = util_decrypt_str_k(sn, c1, &keys128[k]);
+char *s256 = util_decrypt_str_k(sn, c2, &keys256[k]);
+UCX_TEST_ASSERT(!strcmp(s128, strings[i]), "s128 wrong");
+UCX_TEST_ASSERT(!strcmp(s256, strings[i]), "s256 wrong");
 }
 }
+UCX_TEST_END;
 dav_context_destroy(ctx);
 }
-CX_TEST(test_util_encrypt_str_k) {
+UCX_TEST(test_util_encrypt_str_k) {
 DavContext *ctx = dav_context_new();
 DavSession *sn = dav_session_new(ctx, "http://localhost/");
-CX_TEST_DO {
+UCX_TEST_BEGIN;
-for(int k=0;k<16;k++) {
-for(int i=0;i<20;i++) {
+for(int k=0;k<16;k++) {
-char *aes128 = util_encrypt_str_k(sn, strings[i], &keys128[k]);
+for(int i=0;i<20;i++) {
-char *aes256 = util_encrypt_str_k(sn, strings[i], &keys256[k]);
+char *aes128 = util_encrypt_str_k(sn, strings[i], &keys128[k]);
+char *aes256 = util_encrypt_str_k(sn, strings[i], &keys256[k]);
-char *dec1 = util_decrypt_str_k(sn, aes128, &keys128[k]);
-char *dec2 = util_decrypt_str_k(sn, aes256, &keys256[k]);
+char *dec1 = util_decrypt_str_k(sn, aes128, &keys128[k]);
+char *dec2 = util_decrypt_str_k(sn, aes256, &keys256[k]);
-CX_TEST_ASSERT(!strcmp(dec1, strings[i]));
-CX_TEST_ASSERT(!strcmp(dec2, strings[i]));
+UCX_TEST_ASSERT(!strcmp(dec1, strings[i]), "aes128 encrypt failed");
-}
+UCX_TEST_ASSERT(!strcmp(dec2, strings[i]), "aes256 encrypt failed");
 }
 }
-}
+UCX_TEST_END;
-CX_TEST(test_crypto_buffer) {
+}
-CX_TEST_DO {
-for(int i=0;i<32;i++) {
+UCX_TEST(test_crypto_buffer) {
-DavKey *key = i < 16 ? &keys256[i] : &keys128[i%16];
+UCX_TEST_BEGIN;
-for(int j=0;j<20;j++) {
+for(int i=0;i<32;i++) {
-CxBuffer *content = cxBufferCreate(NULL, 256, cxDefaultAllocator, CX_BUFFER_FREE_CONTENTS|CX_BUFFER_AUTO_EXTEND);
+DavKey *key = i < 16 ? &keys256[i] : &keys128[i%16];
-cxBufferPutString(content, strings[j]);
-content->pos = 0;
+for(int j=0;j<20;j++) {
+CxBuffer *content = cxBufferCreate(NULL, 256, cxDefaultAllocator, CX_BUFFER_FREE_CONTENTS|CX_BUFFER_AUTO_EXTEND);
-CxBuffer *enc = aes_encrypt_buffer(content, key);
+cxBufferPutString(content, strings[j]);
-CX_TEST_ASSERT(enc->size >= content->size + 16);
+content->pos = 0;
-char *base64 = util_base64encode(enc->space, enc->size);
+CxBuffer *enc = aes_encrypt_buffer(content, key);
-size_t plainlen = 0;
+UCX_TEST_ASSERT(enc->size >= content->size + 16, "aes_encrypt_buffer failed");
-char *plain = aes_decrypt(base64, &plainlen, key);
+char *base64 = util_base64encode(enc->space, enc->size);
-CX_TEST_ASSERT(plain);
+size_t plainlen = 0;
-CX_TEST_ASSERT(plainlen == content->size);
+char *plain = aes_decrypt(base64, &plainlen, key);
-CX_TEST_ASSERT(!memcmp(plain, content->space, plainlen));
+UCX_TEST_ASSERT(plain, "aes_decrypt failed");
-CxBuffer *dec = aes_decrypt_buffer(enc, key);
+UCX_TEST_ASSERT(plainlen == content->size, "aes_decrypt: wrong length");
-CX_TEST_ASSERT(dec->size == content->size);
+UCX_TEST_ASSERT(!memcmp(plain, content->space, plainlen), "aes_decrypt: wrong content");
-CX_TEST_ASSERT(!memcmp(content->space, dec->space, dec->size));
+CxBuffer *dec = aes_decrypt_buffer(enc, key);
+UCX_TEST_ASSERT(dec->size == content->size, "aes_decrypt_buffer failed");
-cxBufferFree(content);
-cxBufferFree(enc);
+UCX_TEST_ASSERT(!memcmp(content->space, dec->space, dec->size), "decrypted buffer has wrong content");
-cxBufferFree(dec);
-free(base64);
+cxBufferFree(content);
-free(plain);
+cxBufferFree(enc);
-}
+cxBufferFree(dec);
+free(base64);
+free(plain);
 }
 }
-}
+UCX_TEST_END;
-CX_TEST(test_crypto_stream) {
+}
+UCX_TEST(test_crypto_stream) {
 CxBuffer *data = cxBufferCreate(NULL, 1024, cxDefaultAllocator, CX_BUFFER_FREE_CONTENTS|CX_BUFFER_AUTO_EXTEND);
 CxBuffer *cbuf = cxBufferCreate(NULL, 1024, cxDefaultAllocator, CX_BUFFER_FREE_CONTENTS|CX_BUFFER_AUTO_EXTEND);
 CxBuffer *pbuf = cxBufferCreate(NULL, 1024, cxDefaultAllocator, CX_BUFFER_FREE_CONTENTS|CX_BUFFER_AUTO_EXTEND);
-CX_TEST_DO {
+UCX_TEST_BEGIN;
-for(int i=0;i<32;i++) {
-DavKey *key = i < 16 ? &keys256[i] : &keys128[i%16];
+for(int i=0;i<32;i++) {
-for(int j=0;j<20;j++) {
+DavKey *key = i < 16 ? &keys256[i] : &keys128[i%16];
-data->pos = 0;
+for(int j=0;j<20;j++) {
-data->size = 0;
+data->pos = 0;
-size_t slen = strlen(strings[j]);
+data->size = 0;
-cxBufferWrite(strings[j], 1, slen, data);
+size_t slen = strlen(strings[j]);
-cxBufferSeek(data, 0, SEEK_SET);
+cxBufferWrite(strings[j], 1, slen, data);
+cxBufferSeek(data, 0, SEEK_SET);
-cbuf->pos = 0;
-cbuf->size = 0;
+cbuf->pos = 0;
-pbuf->pos = 0;
+cbuf->size = 0;
-pbuf->size = 0;
+pbuf->pos = 0;
+pbuf->size = 0;
-AESEncrypter *enc = aes_encrypter_new(key, data, (dav_read_func)cxBufferRead, NULL);
-char buf[1024];
+AESEncrypter *enc = aes_encrypter_new(key, data, (dav_read_func)cxBufferRead, NULL);
-size_t r = 0;
+char buf[1024];
-while((r = aes_read(buf, 1, 1024, enc)) != 0) {
+size_t r = 0;
-cxBufferWrite(buf, 1, r, cbuf);
+while((r = aes_read(buf, 1, 1024, enc)) != 0) {
-}
+cxBufferWrite(buf, 1, r, cbuf);
-aes_encrypter_close(enc);
-AESDecrypter *dec = aes_decrypter_new(key, pbuf, (dav_write_func)cxBufferWrite);
-aes_write(cbuf->space, 1, cbuf->pos, dec);
-aes_decrypter_shutdown(dec);
-aes_decrypter_close(dec);
-CX_TEST_ASSERT(slen == pbuf->pos);
-CX_TEST_ASSERT(!memcmp(strings[j], pbuf->space, slen));
-data->pos = 0;
-CxBuffer *enc2 = aes_encrypt_buffer(data, key);
-CxBuffer *dec2 = aes_decrypt_buffer(enc2, key);
-CX_TEST_ASSERT(dec2->size == data->size);
-CX_TEST_ASSERT(!memcmp(strings[j], dec2->space, dec2->size));
 }
+aes_encrypter_close(enc);
+AESDecrypter *dec = aes_decrypter_new(key, pbuf, (dav_write_func)cxBufferWrite);
+aes_write(cbuf->space, 1, cbuf->pos, dec);
+aes_decrypter_shutdown(dec);
+aes_decrypter_close(dec);
+UCX_TEST_ASSERT(slen == pbuf->pos, "wrong length after enc-dec");
+UCX_TEST_ASSERT(!memcmp(strings[j], pbuf->space, slen), "wrong content after enc-dec");
+data->pos = 0;
+CxBuffer *enc2 = aes_encrypt_buffer(data, key);
+CxBuffer *dec2 = aes_decrypt_buffer(enc2, key);
+UCX_TEST_ASSERT(dec2->size == data->size, "dec2 has wrong size");
+UCX_TEST_ASSERT(!memcmp(strings[j], dec2->space, dec2->size), "dec2 has wrong content");
 }
 }
+UCX_TEST_END;
 }
 static char *pws[] = {
 "1234",
 "abdefgh",
 { 252, 208, 199, 95, 179, 33, 229, 155, 159, 226, 234, 213, 21, 83, 30, 206  },
 { 252, 208, 199, 95, 179, 33, 229, 155, 159, 226, 234, 213, 21, 83, 30, 206, 174, 151, 174, 207, 58, 169, 148, 244, 37, 88, 44, 46, 72, 172, 15, 214  }
 };
-CX_TEST(test_dav_pw2key) {
+UCX_TEST(test_dav_pw2key) {
-CX_TEST_DO {
+UCX_TEST_BEGIN;
-for(int p=0;p<4;p++) {
-for(int s=0;s<4;s++) {
+for(int p=0;p<4;p++) {
-DavKey *keys[4];
+for(int s=0;s<4;s++) {
-keys[0] =  dav_pw2key(
+DavKey *keys[4];
-pws[p],
+keys[0] =  dav_pw2key(
-salt[s],
+pws[p],
-saltlen[s],
+salt[s],
-DAV_PWFUNC_PBKDF2_SHA256,
+saltlen[s],
-DAV_KEY_AES128);
+DAV_PWFUNC_PBKDF2_SHA256,
-keys[1] = dav_pw2key(
+DAV_KEY_AES128);
-pws[p],
+keys[1] = dav_pw2key(
-salt[s],
+pws[p],
-saltlen[s],
+salt[s],
-DAV_PWFUNC_PBKDF2_SHA256,
+saltlen[s],
-DAV_KEY_AES256);
+DAV_PWFUNC_PBKDF2_SHA256,
-keys[2] = dav_pw2key(
+DAV_KEY_AES256);
-pws[p],
+keys[2] = dav_pw2key(
-salt[s],
+pws[p],
-saltlen[s],
+salt[s],
-DAV_PWFUNC_PBKDF2_SHA512,
+saltlen[s],
-DAV_KEY_AES128);
+DAV_PWFUNC_PBKDF2_SHA512,
-keys[3] = dav_pw2key(
+DAV_KEY_AES128);
-pws[p],
+keys[3] = dav_pw2key(
-salt[s],
+pws[p],
-saltlen[s],
+salt[s],
-DAV_PWFUNC_PBKDF2_SHA512,
+saltlen[s],
-DAV_KEY_AES256);
+DAV_PWFUNC_PBKDF2_SHA512,
+DAV_KEY_AES256);
-for(int i=0;i<4;i++) {
-DavKey *key = keys[i];
+for(int i=0;i<4;i++) {
+DavKey *key = keys[i];
-int index = 16*p + 4*s + i;
-int keylen = index % 2 == 0 ? 16 : 32;
+int index = 16*p + 4*s + i;
+int keylen = index % 2 == 0 ? 16 : 32;
-CX_TEST_ASSERT(key);
-CX_TEST_ASSERT(keylen == key->length);
+UCX_TEST_ASSERT(key, "no key");
-CX_TEST_ASSERT(!memcmp(key->data, pwgenkeys[index], keylen));
+UCX_TEST_ASSERT(keylen == key->length, "wrong key length");
-}
+UCX_TEST_ASSERT(!memcmp(key->data, pwgenkeys[index], keylen), "wrong key data");
 }
 }
+}
-}
-}
+UCX_TEST_END;
+}

Mercurial > hg > dav / file comparison

comparison: test/crypto.c

test/crypto.c