scip/pcp
1
0
Fork 0
mirror of https://codeberg.org/scip/pcp.git synced 2025-12-17 12:00:56 +01:00
Code Issues Packages Projects Releases Wiki Activity

adapt unittests to new pcp context stuff

Browse Source
This commit is contained in:
git@daemon.de
2014-05-05 11:57:57 +02:00
parent 86e815346a
commit 01f149d4f1
6 changed files with 76 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
tests/buffertest.c
View File

@@ -4,6 +4,7 @@
int main() {
/* testing basic Buffer api */
Buffer *test = buffer_new(16, "test");
PCPCTX *ptx = ptx_new();
byte *a = ucmalloc(32);
byte *b = ucmalloc(32);
@@ -92,7 +93,7 @@ int main() {
munmap(r, rs);
fclose(RFD);
fatals_ifany();
fatals_ifany(ptx);
return 0;
}

73
tests/cpptest.cpp
View File

@@ -14,76 +14,76 @@ void pr(string name, unsigned char *data, size_t len) {
cout << endl;
}
FILE *_openwr(string file) {
FILE *_openwr(string file, PcpContext &ptx) {
FILE *fd;
if((fd = fopen(file.c_str(), "wb+")) == NULL) {
throw pcp::exception("Could not open output file " + file + "\n");
throw pcp::exception(ptx, "Could not open output file " + file + "\n");
}
return fd;
}
FILE *_openrd(string file) {
FILE *_openrd(string file, PcpContext &ptx) {
FILE *fd;
if((fd = fopen(file.c_str(), "rb")) == NULL) {
throw pcp::exception("Could not open input file " + file + "\n");
throw pcp::exception(ptx, "Could not open input file " + file + "\n");
}
return fd;
}
void test0() {
void test0(PcpContext &ptx) {
// test keygen and crypto
FILE *CLEAR, *CIPHER, *DECRYPTED;
Key A = Key("a", "alicia", "alicia@local");
Key B = Key("b", "bobby", "bobby@local");
Key A = Key(ptx, "a", "alicia", "alicia@local");
Key B = Key(ptx, "b", "bobby", "bobby@local");
PubKey PA = A.get_public();
PubKey PB = B.get_public();
A.decrypt("a");
B.decrypt("b");
Crypto A2B(A, PB);
Crypto B2A(B, PA);
Crypto A2B(ptx, A, PB);
Crypto B2A(ptx, B, PA);
CLEAR = _openwr("testcppclear");
CLEAR = _openwr("testcppclear", ptx);
fprintf(CLEAR, "HALLO\n");
fclose(CLEAR);
CIPHER = _openwr("testcpcipher");
CLEAR = _openrd("testcppclear");
CIPHER = _openwr("testcpcipher", ptx);
CLEAR = _openrd("testcppclear", ptx);
if(A2B.encrypt(CLEAR, CIPHER, false)) {
CIPHER = _openrd("testcpcipher");
DECRYPTED = _openwr("testcppdecrypted");
CIPHER = _openrd("testcpcipher", ptx);
DECRYPTED = _openwr("testcppdecrypted", ptx);
if(B2A.decrypt(CIPHER, DECRYPTED, false)) {
DECRYPTED = _openrd("testcppdecrypted");
DECRYPTED = _openrd("testcppdecrypted", ptx);
char *got = (char *)ucmalloc(10);
if(fread(got, 1, 6, DECRYPTED) < 6) {
throw pcp::exception("read error, could not read decrypted content");
throw pcp::exception(ptx, "read error, could not read decrypted content");
}
if(strncmp(got, "HALLO", 5) != 0) {
throw pcp::exception();
throw pcp::exception(ptx);
}
}
else
throw pcp::exception("failed to decrypt");
throw pcp::exception(ptx, "failed to decrypt");
}
else
throw pcp::exception("failed to encrypt");
throw pcp::exception(ptx, "failed to encrypt");
cout << "0 ok" << endl;
}
void test1() {
void test1(PcpContext &ptx) {
// test the vault
Key A = Key("a", "alicia", "alicia@local");
Key B = Key("b", "bobby", "bobby@local");
Key A = Key(ptx, "a", "alicia", "alicia@local");
Key B = Key(ptx, "b", "bobby", "bobby@local");
PubKey PA = A.get_public();
PubKey PB = B.get_public();
Vault vault = Vault("vcpp1");
Vault vault = Vault(ptx, "vcpp1");
vault.key_add(A);
vault.pubkey_add(PB);
@@ -102,12 +102,12 @@ void test1() {
}
if(gotp == false || gots == false)
throw pcp::exception("wtf - didnt find installed keys");
throw pcp::exception(ptx, "wtf - didnt find installed keys");
else
cout << "1 ok" << endl;
}
void test2() {
void test2(PcpContext &ptx) {
// try importing a key from disk
ifstream pf("key-bobby-pub");
string z;
@@ -118,22 +118,22 @@ void test2() {
if(strlen(buf) > 0)
z += buf + string("\n");
}
PubKey B(z);
PubKey B(ptx, z);
//cout << B.to_text();
cout << "2 ok" << endl;
}
void test3() {
void test3(PcpContext &ptx) {
// signature test
Key A = Key("a", "alicia", "alicia@local");
Key A = Key(ptx, "a", "alicia", "alicia@local");
A.decrypt("a");
PubKey PA = A.get_public();
string message = "hallo baby";
Signature SigA(A);
Signature SigB(PA);
Signature SigA(ptx, A);
Signature SigB(ptx, PA);
if(SigA.sign((unsigned char*)message.c_str(), message.length()))
if(SigB.verify(SigA.sig) )
@@ -158,29 +158,30 @@ void test4() {
int main(int argc, char **argv) {
sodium_init();
PcpContext ptx;
try {
if(argc < 2)
throw pcp::exception("usage: cpptest N");
throw pcp::exception(ptx, "usage: cpptest N");
switch(argv[1][0]) {
case '0':
test0();
test0(ptx);
break;
case '1':
test1();
test1(ptx);
break;
case '2':
test2();
test2(ptx);
break;
case '3':
test3();
test3(ptx);
break;
case '4':
test3();
test4();
break;
default:

18
tests/decodertest.c
View File

@@ -21,6 +21,8 @@ int main(int argc, char **argv) {
size_t clearlen = 256;
size_t zlen = (clearlen * 5 / 4);
PCPCTX *ptx = ptx_new();
if(argc < 2) {
fprintf(stderr, "Usage: decodertest <N>\n");
return 1;
@@ -40,8 +42,8 @@ int main(int argc, char **argv) {
if(z85 == NULL) {
ret = FALSE;
if(PCP_ERRSET == 0) {
fatal("failed to encoded data to Z85\n");
if(ptx->pcp_errset == 0) {
fatal(ptx, "failed to encoded data to Z85\n");
}
goto OUT;
}
@@ -103,14 +105,14 @@ int main(int argc, char **argv) {
/* line decoder */
char *raw = pcp_readz85string(buffer_get(zdone), buffer_size(zdone));
char *raw = pcp_readz85string(ptx, buffer_get(zdone), buffer_size(zdone));
if(raw == NULL) {
/* unexpected */
ret = FALSE;
}
else {
back = pcp_z85_decode(raw, &zlen);
back = pcp_z85_decode(ptx, raw, &zlen);
if(back == NULL) {
if(mode > 3) {
/* expected fail */
@@ -137,8 +139,8 @@ int main(int argc, char **argv) {
if(back != NULL) {
if(mode <= 3 && memcmp(back, clear, 256) != 0) {
ret = FALSE;
if(PCP_ERRSET == 0) {
fatal("decoded content doesn't match\n");
if(ptx->pcp_errset == 0) {
fatal(ptx, "decoded content doesn't match\n");
}
}
}
@@ -157,8 +159,10 @@ int main(int argc, char **argv) {
}
else {
fprintf(stdout, "%d - failed\n", mode);
fatals_ifany();
fatals_ifany(ptx);
}
ptx_clean(ptx);
return ret;
}

3
tests/gencheader.c
View File

@@ -16,12 +16,13 @@ int main() {
pcp_key_t *a = pcpkey_new();
pcp_key_t *b = pcpkey_new();
PCPCTX *ptx = ptx_new();
pcp_pubkey_t *p = pcpkey_pub_from_secret(b);
unsigned char m[12] = "hallo world";
size_t clen;
unsigned char *c = pcp_box_encrypt(a, p, m, 12, &clen);
unsigned char *c = pcp_box_encrypt(ptx, a, p, m, 12, &clen);
unsigned char *n = ucmalloc(24);
memcpy(n, c, 24);

24
tests/invalidkeys.c
View File

@@ -11,26 +11,26 @@ int main() {
strcpy(m, "xxxx");
sodium_init();
PCPCTX *ptx = ptx_new();
pcp_key_t *k = pcpkey_new ();
memcpy(k->owner, o, 8);
memcpy(k->mail, m, 8);
pcp_key_t *key = pcpkey_encrypt(k, pw);
pcp_key_t *key = pcpkey_encrypt(ptx, k, pw);
int i;
for(i=0; i<3; i++)
mkinvalid_secret(key, i);
mkinvalid_secret(ptx, key, i);
for(i=0; i<4; i++)
mkinvalid_public(key, i);
mkinvv("testvault-invalidheader", 0);
mkinvv("testvault-invalidversion", 1);
mkinvv("testvault-invaliditemsize", 2);
mkinvv("testvault-invaliditemtype", 3);
mkinvv("testvault-invalidkeytype", 4);
mkinvv(ptx, "testvault-invalidheader", 0);
mkinvv(ptx, "testvault-invalidversion", 1);
mkinvv(ptx, "testvault-invaliditemsize", 2);
mkinvv(ptx, "testvault-invaliditemtype", 3);
mkinvv(ptx, "testvault-invalidkeytype", 4);
return 0;
}
@@ -43,9 +43,9 @@ void pr(char *t, unsigned char *b, size_t s) {
printf("\n");
}
void mkinvv(const char *name, int type) {
void mkinvv(PCPCTX *ptx, const char *name, int type) {
unlink(name);
vault_t *v = pcpvault_new((char *)name, 0);
vault_t *v = pcpvault_new(ptx, (char *)name, 0);
vault_item_header_t *item = ucmalloc(sizeof(vault_item_header_t));
vault_header_t *header = ucmalloc(sizeof(vault_header_t));
@@ -135,7 +135,7 @@ void mkinvalid_public(pcp_key_t *k, int type) {
free(key);
}
void mkinvalid_secret(pcp_key_t *k, int type) {
void mkinvalid_secret(PCPCTX *ptx, pcp_key_t *k, int type) {
pcp_key_t *key = ucmalloc(sizeof(pcp_key_t));
memcpy(key, k, sizeof(pcp_key_t));
FILE *fd = NULL;
@@ -159,7 +159,7 @@ void mkinvalid_secret(pcp_key_t *k, int type) {
if(fd != NULL) {
pcp_dumpkey(key);
Buffer *b = pcp_export_secret(key, "xxx");
Buffer *b = pcp_export_secret(ptx, key, "xxx");
fwrite(buffer_get(b), 1, buffer_size(b), fd);
fclose(fd);
}

17
tests/sample.c
View File

@@ -5,8 +5,12 @@ int main() {
pcp_key_t *alice, *bob;
pcp_pubkey_t *alicepub, *bobpub, *pubhash;
Pcpstream *clear_in, *crypt_out, *clear_out;
PCPCTX *ptx;
char message[] = "hello world";
/* we always need a context */
ptx = ptx_new();
/* generate the keypairs for both */
alice = pcpkey_new();
bob = pcpkey_new();
@@ -30,7 +34,7 @@ int main() {
/* actually encrypt the message, don't sign it
Alice is the sender, Bob is the recipient */
pcp_encrypt_stream(clear_in, crypt_out, alice, pubhash, 0);
pcp_encrypt_stream(ptx, clear_in, crypt_out, alice, pubhash, 0);
/* now, print the encrypted result */
fprintf(stderr, "Alice encrypted %"FMT_SIZE_T" bytes for Bob:\n", (SIZE_T_CAST)strlen(message));
@@ -42,14 +46,13 @@ int main() {
clear_out = ps_new_outbuffer();
/* in order for the decryptor find the senders public key,
we need to put it into the global hash. this step can be
we need to put it into the context hash. this step can be
omitted when using a Vault. */
pcppubkey_hash = NULL;
HASH_ADD_STR( pcppubkey_hash , id, alicepub);
pcphash_add(ptx, alicepub, alicepub->type);
/* try to decrypt the message */
if(pcp_decrypt_stream(crypt_out, clear_out, bob, NULL, 0) == 0)
fatals_ifany();
if(pcp_decrypt_stream(ptx, crypt_out, clear_out, bob, NULL, 0) == 0)
fatals_ifany(ptx);
else {
/* and finally print out the decrypted message */
fprintf(stderr, "Bob decrypted %"FMT_SIZE_T" bytes from Alice:\n", (SIZE_T_CAST)buffer_size(ps_buffer(crypt_out)));
@@ -60,6 +63,8 @@ int main() {
ps_close(crypt_out);
ps_close(clear_out);
ptx_clean(ptx);
free(alice);
free(alicepub);
free(bob);