Changeset 611
- Timestamp:
- 09/03/08 09:37:32
- Files:
-
- openpgpsdk/trunk/src/lib/create.c (modified) (8 diffs)
- openpgpsdk/trunk/src/lib/keyring.c (modified) (20 diffs)
- openpgpsdk/trunk/src/lib/memory.c (modified) (2 diffs)
- openpgpsdk/trunk/src/lib/readerwriter.c (modified) (2 diffs)
- openpgpsdk/trunk/src/lib/util.c (modified) (3 diffs)
Legend:
- Unmodified
- Added
- Removed
- Modified
- Copied
- Moved
openpgpsdk/trunk/src/lib/create.c
r599 r611 397 397 398 398 399 ops_boolean_t ops_write_transferable_public_key(const ops_keydata_t *key, ops_boolean_t armoured, ops_create_info_t *info) 399 /** 400 \ingroup HighLevel_Key 401 402 \brief Writes a transferable PGP public key to the given output stream. 403 404 \param keydata Key to be written 405 \param armoured Flag is set for armoured output 406 \param info Output stream 407 408 Example code: 409 \code 410 void example(const ops_keydata_t* keydata) 411 { 412 ops_boolean_t armoured=ops_true; 413 char* filename="/tmp/testkey.asc"; 414 415 int fd; 416 ops_boolean_t overwrite=ops_true; 417 ops_create_info_t* cinfo; 418 419 fd=ops_setup_file_write(&cinfo, filename, overwrite); 420 ops_write_transferable_public_key(keydata,armoured,cinfo); 421 ops_teardown_file_write(cinfo,fd); 422 } 423 \endcode 424 */ 425 426 ops_boolean_t ops_write_transferable_public_key(const ops_keydata_t *keydata, ops_boolean_t armoured, ops_create_info_t *info) 400 427 { 401 428 ops_boolean_t rtn; … … 406 433 407 434 // public key 408 rtn=ops_write_struct_public_key(&key ->key.skey.public_key,info);435 rtn=ops_write_struct_public_key(&keydata->key.skey.public_key,info); 409 436 if (rtn!=ops_true) 410 437 return rtn; … … 413 440 414 441 // user ids and corresponding signatures 415 for (i=0; i<key ->nuids; i++)416 { 417 ops_user_id_t* uid=&key ->uids[i];442 for (i=0; i<keydata->nuids; i++) 443 { 444 ops_user_id_t* uid=&keydata->uids[i]; 418 445 419 446 rtn=ops_write_struct_user_id(uid, info); … … 423 450 424 451 // find signature for this packet if it exists 425 for (j=0; j<key ->nsigs; j++)452 for (j=0; j<keydata->nsigs; j++) 426 453 { 427 sigpacket_t* sig=&key ->sigs[i];454 sigpacket_t* sig=&keydata->sigs[i]; 428 455 if (!strcmp((char *)sig->userid->user_id, (char *)uid->user_id)) 429 456 { … … 448 475 } 449 476 450 ops_boolean_t ops_write_transferable_secret_key(const ops_keydata_t *key, const unsigned char* passphrase, const size_t pplen, ops_boolean_t armoured, ops_create_info_t *info) 477 /** 478 \ingroup HighLevel_Key 479 480 \brief Writes a transferable PGP secret key to the given output stream. 481 482 \param keydata Key to be written 483 \param armoured Flag is set for armoured output 484 \param info Output stream 485 486 Example code: 487 \code 488 void example(const ops_keydata_t* keydata) 489 { 490 const unsigned char* passphrase=NULL; 491 const size_t passphraselen=0; 492 ops_boolean_t armoured=ops_true; 493 494 int fd; 495 char* filename="/tmp/testkey.asc"; 496 ops_boolean_t overwrite=ops_true; 497 ops_create_info_t* cinfo; 498 499 fd=ops_setup_file_write(&cinfo, filename, overwrite); 500 ops_write_transferable_secret_key(keydata,passphrase,pplen,armoured,cinfo); 501 ops_teardown_file_write(cinfo,fd); 502 } 503 \endcode 504 */ 505 506 ops_boolean_t ops_write_transferable_secret_key(const ops_keydata_t *keydata, const unsigned char* passphrase, const size_t pplen, ops_boolean_t armoured, ops_create_info_t *info) 451 507 { 452 508 ops_boolean_t rtn; … … 457 513 458 514 // public key 459 rtn=ops_write_struct_secret_key(&key ->key.skey,passphrase,pplen,info);515 rtn=ops_write_struct_secret_key(&keydata->key.skey,passphrase,pplen,info); 460 516 if (rtn!=ops_true) 461 517 return rtn; … … 464 520 465 521 // user ids and corresponding signatures 466 for (i=0; i<key ->nuids; i++)467 { 468 ops_user_id_t* uid=&key ->uids[i];522 for (i=0; i<keydata->nuids; i++) 523 { 524 ops_user_id_t* uid=&keydata->uids[i]; 469 525 470 526 rtn=ops_write_struct_user_id(uid, info); … … 474 530 475 531 // find signature for this packet if it exists 476 for (j=0; j<key ->nsigs; j++)532 for (j=0; j<keydata->nsigs; j++) 477 533 { 478 sigpacket_t* sig=&key ->sigs[i];534 sigpacket_t* sig=&keydata->sigs[i]; 479 535 if (!strcmp((char *)sig->userid->user_id, (char *)uid->user_id)) 480 536 { openpgpsdk/trunk/src/lib/keyring.c
r574 r611 46 46 #include <openpgpsdk/final.h> 47 47 48 void ops_keydata_free(ops_keydata_t *key) 48 /** 49 \ingroup HighLevel_KeyringMemory 50 51 \brief Creates a new ops_keydata_t struct 52 53 \return A new ops_keydata_t struct, initialised to zero. 54 55 \note The returned ops_keydata_t struct must be freed after use with ops_keydata_free. 56 */ 57 58 ops_keydata_t *ops_keydata_new(void) 59 { return ops_mallocz(sizeof(ops_keydata_t)); } 60 61 62 /** 63 \ingroup HighLevel_KeyringMemory 64 65 \brief Frees keydata and its memory 66 67 \param key Key to be freed. 68 69 \note This frees the keydata itself, as well as any other memory alloc-ed by it. 70 */ 71 void ops_keydata_free(ops_keydata_t *keydata) 49 72 { 50 73 unsigned n; 51 74 52 for(n=0 ; n < key ->nuids ; ++n)53 ops_user_id_free(&key ->uids[n]);54 free(key ->uids);55 key ->uids=NULL;56 key ->nuids=0;57 58 for(n=0 ; n < key ->npackets ; ++n)59 ops_packet_free(&key ->packets[n]);60 free(key ->packets);61 key ->packets=NULL;62 key ->npackets=0;63 64 if(key ->type == OPS_PTAG_CT_PUBLIC_KEY)65 ops_public_key_free(&key ->key.pkey);75 for(n=0 ; n < keydata->nuids ; ++n) 76 ops_user_id_free(&keydata->uids[n]); 77 free(keydata->uids); 78 keydata->uids=NULL; 79 keydata->nuids=0; 80 81 for(n=0 ; n < keydata->npackets ; ++n) 82 ops_packet_free(&keydata->packets[n]); 83 free(keydata->packets); 84 keydata->packets=NULL; 85 keydata->npackets=0; 86 87 if(keydata->type == OPS_PTAG_CT_PUBLIC_KEY) 88 ops_public_key_free(&keydata->key.pkey); 66 89 else 67 ops_secret_key_free(&key->key.skey); 68 69 free(key); 70 } 90 ops_secret_key_free(&keydata->key.skey); 91 92 free(keydata); 93 } 94 95 /** 96 \ingroup HighLevel_Key 97 98 \brief Returns the public key in the given keydata. 99 \param keydata 100 101 \return Pointer to public key 102 103 \note This is not a copy, do not free it after use. 104 */ 71 105 72 106 const ops_public_key_t * 73 ops_get_public_key_from_data(const ops_keydata_t *data) 74 { 75 if(data->type == OPS_PTAG_CT_PUBLIC_KEY) 76 return &data->key.pkey; 77 return &data->key.skey.public_key; 78 } 79 80 ops_boolean_t ops_key_is_secret(const ops_keydata_t *data) 107 ops_get_public_key_from_data(const ops_keydata_t *keydata) 108 { 109 if(keydata->type == OPS_PTAG_CT_PUBLIC_KEY) 110 return &keydata->key.pkey; 111 return &keydata->key.skey.public_key; 112 } 113 114 /** 115 \ingroup HighLevel_Key 116 117 \brief Check whether this is a secret key or not. 118 */ 119 120 ops_boolean_t ops_is_key_secret(const ops_keydata_t *data) 81 121 { return data->type != OPS_PTAG_CT_PUBLIC_KEY; } 122 123 /** 124 \ingroup HighLevel_Key 125 126 \brief Returns the secret key in the given keydata. 127 128 \note This is not a copy, do not free it after use. 129 130 \note This returns a const. If you need to be able to write to this pointer, use ops_get_writable_secret_key_from_data 131 */ 82 132 83 133 const ops_secret_key_t * … … 89 139 return &data->key.skey; 90 140 } 141 142 /** 143 \ingroup HighLevel_Key 144 145 \brief Returns the secret key in the given keydata. 146 147 \note This is not a copy, do not free it after use. 148 149 \note If you do not need to be able to modify this key, there is an equivalent read-only function ops_get_secret_key_from_data. 150 */ 91 151 92 152 ops_secret_key_t * … … 214 274 } 215 275 216 ops_boolean_t ops_key_is_supported(const ops_keydata_t *key) 217 { 218 if ( key->type == OPS_PTAG_CT_PUBLIC_KEY ) { 219 if ( key->key.pkey.algorithm == OPS_PKA_RSA ) { 276 /** 277 \ingroup HighLevel_Key 278 279 \brief Checks whether key's algorithm and type are supported by OpenPGP::SDK 280 281 \param keydata Key to be checked 282 283 \return ops_true if key algorithm and type are supported by OpenPGP::SDK; ops_false if not 284 */ 285 286 ops_boolean_t ops_is_key_supported(const ops_keydata_t *keydata) 287 { 288 if ( keydata->type == OPS_PTAG_CT_PUBLIC_KEY ) { 289 if ( keydata->key.pkey.algorithm == OPS_PKA_RSA ) { 220 290 return ops_true; 221 291 } 222 } else if ( key ->type == OPS_PTAG_CT_PUBLIC_KEY ) {223 if ( key ->key.skey.algorithm == OPS_PKA_RSA ) {292 } else if ( keydata->type == OPS_PTAG_CT_PUBLIC_KEY ) { 293 if ( keydata->key.skey.algorithm == OPS_PKA_RSA ) { 224 294 return ops_true; 225 295 } … … 229 299 230 300 231 const ops_keydata_t* ops_keyring_get_key(const ops_keyring_t *keyring, int index) 232 { 301 /** 302 \ingroup HighLevel_KeyringFind 303 304 \brief Returns key inside a keyring, chosen by index 305 306 \param keyring Pointer to existing keyring 307 \param index Index of required key 308 309 \note Index starts at 0 310 311 \note This returns a pointer to the original key, not a copy. You do not need to free the key after use. 312 313 \return Pointer to the required key; or NULL if index too large. 314 315 Example code: 316 \code 317 void example(const ops_keyring_t* keyring) 318 { 319 ops_keydata_t* keydata=NULL; 320 keydata=ops_keyring_get_key_by_index(keyring, 0); 321 ... 322 } 323 \endcode 324 */ 325 326 const ops_keydata_t* ops_keyring_get_key_by_index(const ops_keyring_t *keyring, int index) 327 { 328 if (index >= keyring->nkeys) 329 return NULL; 233 330 return &keyring->keys[index]; 234 331 } … … 373 470 } 374 471 375 ops_keydata_t *ops_keydata_new(void)376 { return ops_mallocz(sizeof(ops_keydata_t)); }377 378 472 void ops_keydata_init(ops_keydata_t* keydata, const ops_content_tag_t type) 379 473 { … … 384 478 } 385 479 386 /*! \file 387 \brief Standard API keyring functions 388 389 */ 390 391 /** @defgroup StdKeyring Keyring 392 \ingroup StandardAPI 393 394 @defgroup StdKeyringFile Keyring File Operations 395 \ingroup StdKeyring 396 \brief Keyring Open/Read/Write/Close 397 480 /** 398 481 Example Usage: 399 482 \code … … 414 497 */ 415 498 416 /**417 @defgroup StdKeyringFind Keyfind Find Operations418 \ingroup StdKeyring419 Find Key or its info within keyring420 421 Example Usage:422 \code423 424 // definition of variables425 ops_keyring_t keyring;426 unsigned char* keyid;427 ops_key_data_t *key;428 429 // Read keyring from file430 ops_keyring_read_from_file(&keyring,"~/.gnupg/pubring.gpg");431 432 // Search for keys433 434 // - get Key ID from given userid435 keyid=ops_keyring_find_keyid_by_userid (keyring, "user@domain.com")436 437 // - now get key from Key ID438 key=ops_keyring_find_key_by_id(keyring, keyid);439 440 // do something with key441 ...442 443 // Free memory alloc-ed in ops_keyring_read_from_file()444 ops_keyring_free();445 \endcode446 */447 448 499 static ops_parse_cb_return_t 449 500 cb_keyring_read(const ops_parser_content_t *content_, … … 451 502 452 503 /** 453 \ingroup StdKeyringFile 454 455 Reads a keyring from a file 456 457 \param keyring Ptr to existing keyring 458 \param file Filename of keyring 459 504 \ingroup HighLevel_KeyringRead 505 506 \brief Reads a keyring from a file 507 508 \param keyring Pointer to an existing ops_keyring_t struct 509 \param armour ops_true if file is armoured; else ops_false 510 \param filename Filename of keyring to be read 511 512 \return ops true if OK; ops_false on error 513 460 514 \note Keyring struct must already exist. 461 515 … … 466 520 \note If you call this twice on the same keyring struct, without calling 467 521 ops_keyring_free() between these calls, you will introduce a memory leak. 468 */ 522 523 Example code: 524 \code 525 ops_keyring_t* keyring=ops_mallocz(sizeof *keyring); 526 ops_boolean_t armoured=ops_false; 527 ops_keyring_read_from_file(keyring, armoured, "~/.gnupg/pubring.gpg"); 528 ... 529 ops_keyring_free(keyring); 530 free (keyring); 531 532 \endcode 533 */ 534 469 535 ops_boolean_t ops_keyring_read_from_file(ops_keyring_t *keyring, const ops_boolean_t armour, const char *filename) 470 536 { … … 472 538 int fd; 473 539 ops_boolean_t res = ops_true; 474 475 //memset(keyring,'\0',sizeof *keyring);476 540 477 541 pinfo=ops_parse_info_new(); … … 511 575 ops_print_errors(ops_parse_info_get_errors(pinfo)); 512 576 577 if (armour) 578 ops_reader_pop_dearmour(pinfo); 579 513 580 close(fd); 514 581 … … 519 586 520 587 /** 521 \ingroup StdKeyring 522 523 Reads a keyring from memory 524 525 \param keyring Ptr to existing keyring 526 \param mem ptr to memory struct containing keyring info 527 588 \ingroup HighLevel_KeyringRead 589 590 \brief Reads a keyring from memory 591 592 \param keyring Pointer to existing ops_keyring_t struct 593 \param armour ops_true if file is armoured; else ops_false 594 \param mem Pointer to a ops_memory_t struct containing keyring to be read 595 596 \return ops true if OK; ops_false on error 597 528 598 \note Keyring struct must already exist. 529 599 … … 534 604 \note If you call this twice on the same keyring struct, without calling 535 605 ops_keyring_free() between these calls, you will introduce a memory leak. 536 */ 537 ops_boolean_t ops_keyring_read_from_mem(ops_keyring_t *keyring, ops_memory_t* mem) 538 { 539 // \todo currently assuming this is an armoured key. 540 606 Example code: 607 \code 608 ops_memory_t* mem; // Filled with keyring packets 609 ops_keyring_t* keyring=ops_mallocz(sizeof *keyring); 610 ops_boolean_t armoured=ops_false; 611 ops_keyring_read_from_mem(keyring, armoured, mem); 612 ... 613 ops_keyring_free(keyring); 614 free (keyring); 615 \endcode 616 */ 617 ops_boolean_t ops_keyring_read_from_mem(ops_keyring_t *keyring, const ops_boolean_t armour, ops_memory_t* mem) 618 { 541 619 ops_parse_info_t *pinfo=NULL; 542 620 ops_boolean_t res = ops_true; 543 621 544 // \todo need to free memory first?545 //memset(keyring,'\0',sizeof *keyring);546 547 622 pinfo=ops_parse_info_new(); 548 623 ops_parse_options(pinfo,OPS_PTAG_SS_ALL,OPS_PARSE_PARSED); … … 550 625 ops_setup_memory_read(&pinfo, mem, NULL, cb_keyring_read); 551 626 552 ops_reader_push_dearmour(pinfo,ops_false,ops_false,ops_true); 627 // ops_reader_push_dearmour(pinfo,ops_false,ops_false,ops_true); 628 629 if (armour) 630 { ops_reader_push_dearmour(pinfo, ops_false, ops_false, ops_false); } 553 631 554 632 if ( ops_parse_and_accumulate(keyring,pinfo) == 0 ) … … 562 640 ops_print_errors(ops_parse_info_get_errors(pinfo)); 563 641 564 ops_reader_pop_dearmour(pinfo); 642 if (armour) 643 ops_reader_pop_dearmour(pinfo); 565 644 566 645 // don't call teardown_memory_read because memory was passed in … … 571 650 572 651 /** 573 \ingroup StdKeyringFile652 \ingroup HighLevel_KeyringMemory 574 653 575 Frees alloc-ed memory654 \brief Frees keyring's contents (but not keyring itself) 576 655 577 656 \param keyring Keyring whose data is to be freed … … 588 667 589 668 /** 590 \ingroup StdKeyringFind591 592 Finds key in keyring from its Key ID669 \ingroup HighLevel_KeyringFind 670 671 \brief Finds key in keyring from its Key ID 593 672 594 673 \param keyring Keyring to be searched 595 674 \param keyid ID of required key 596 675 597 \return Ptr to key, if found; NULL, if not found 676 \return Pointer to key, if found; NULL, if not found 677 678 \note This returns a pointer to the key inside the given keyring, not a copy. Do not free it after use. 679 680 Example code: 681 \code 682 void example(ops_keyring_t* keyring) 683 { 684 ops_keydata_t* keydata=NULL; 685 unsigned char keyid[OPS_KEY_ID_SIZE]; // value set elsewhere 686 keydata=ops_keyring_find_key_by_id(keyring,keyid); 687 ... 688 } 689 \endcode 598 690 */ 599 691 const ops_keydata_t * … … 616 708 617 709 /** 618 \ingroup StdKeyringFind619 620 Finds key from its User ID710 \ingroup HighLevel_KeyringFind 711 712 \brief Finds key from its User ID 621 713 622 714 \param keyring Keyring to be searched 623 715 \param userid User ID of required key 624 716 625 \return Ptr to Key, if found; NULL, if not found 717 \return Pointer to Key, if found; NULL, if not found 718 719 \note This returns a pointer to the key inside the keyring, not a copy. Do not free it. 720 721 Example code: 722 \code 723 void example(ops_keyring_t* keyring) 724 { 725 ops_keydata_t* keydata=NULL; 726 keydata=ops_keyring_find_key_by_userid(keyring,"user@domain.com"); 727 ... 728 } 729 \endcode 626 730 */ 627 731 const ops_keydata_t * … … 650 754 651 755 /** 652 \ingroup StdKeyringList653 654 List keys in keyring756 \ingroup HighLevel_KeyringList 757 758 \brief Prints all keys in keyring to stdout. 655 759 656 760 \param keyring Keyring to use 657 \param match optional string to match 658 761 762 \return none 763 764 Example code: 765 \code 766 void example() 767 { 768 ops_keyring_t* keyring=ops_mallocz(sizeof *keyring); 769 ops_boolean_t armoured=ops_false; 770 ops_keyring_read_from_file(keyring, armoured, "~/.gnupg/pubring.gpg"); 771 772 ops_keyring_list(keyring); 773 774 ops_keyring_free(keyring); 775 free (keyring); 776 } 777 \endcode 659 778 */ 660 779 661 780 void 662 ops_keyring_list(const ops_keyring_t* keyring, 663 const char* match) 781 ops_keyring_list(const ops_keyring_t* keyring) 664 782 { 665 783 int n; … … 672 790 for(i=0; i<key->nuids; i++) 673 791 { 674 if (match) 675 printf ("*** match %s\n", match); 676 // if match, compare 677 // if(!strcmp((char *)keyring->keys[n].uids[i].user_id,userid)) 678 // return &keyring->keys[n].keyid[0]; 679 if (ops_key_is_secret(key)) 792 if (ops_is_key_secret(key)) 680 793 ops_print_secret_keydata(key); 681 794 else openpgpsdk/trunk/src/lib/memory.c
r574 r611 131 131 } 132 132 133 /** 134 \ingroup HighLevel_Misc 135 \brief Create a new zeroed ops_memory_t 136 \return Pointer to new ops_memory_t 137 \note Free using ops_memory_free() after use. 138 */ 139 133 140 ops_memory_t *ops_memory_new() 134 141 { return ops_mallocz(sizeof(ops_memory_t)); } 142 143 /** 144 \ingroup HighLevel_Misc 145 \brief Free memory 146 \param mem Memory to be freed 147 */ 135 148 136 149 void ops_memory_free(ops_memory_t *mem) … … 140 153 } 141 154 155 /** 156 \ingroup HighLevel_Misc 157 \brief Get length of data stored in ops_memory_t struct 158 \return Number of bytes in data 159 */ 142 160 size_t ops_memory_get_length(const ops_memory_t *mem) 143 161 { return mem->length; } 144 162 163 /** 164 \ingroup HighLevel_Misc 165 \brief Get data stored in ops_memory_t struct 166 \return Pointer to data 167 */ 145 168 void *ops_memory_get_data(ops_memory_t *mem) 146 169 { return mem->buf; } openpgpsdk/trunk/src/lib/readerwriter.c
r590 r611 252 252 } 253 253 254 /** 255 \ingroup Core_Callbacks 256 257 \brief Callback to get secret key, decrypting if necessary. 258 259 @verbatim 260 This callback does the following: 261 * finds the session key in the keyring 262 * gets a passphrase if required 263 * decrypts the secret key, if necessary 264 * sets the secret_key in the content struct 265 @endverbatim 266 */ 267 254 268 ops_parse_cb_return_t 255 269 callback_cmd_get_secret_key(const ops_parser_content_t *content_,ops_parse_cb_info_t *cbinfo) … … 267 281 case OPS_PARSER_CMD_GET_SECRET_KEY: 268 282 cbinfo->cryptinfo.keydata=ops_keyring_find_key_by_id(cbinfo->cryptinfo.keyring,content->get_secret_key.pk_session_key->key_id); 269 if (!cbinfo->cryptinfo.keydata || !ops_ key_is_secret(cbinfo->cryptinfo.keydata))283 if (!cbinfo->cryptinfo.keydata || !ops_is_key_secret(cbinfo->cryptinfo.keydata)) 270 284 return 0; 271 285 openpgpsdk/trunk/src/lib/util.c
r574 r611 82 82 83 83 /** 84 * \ingroup Utils 85 * 86 * Initialise OpenPGP:SDK. This <b>must</b> be called before any other 87 * OpenPGP:SDK function is used. 84 * \ingroup HighLevel_Misc 85 * \brief Initialises OpenPGP::SDK. To be called before any other OPS function. 88 86 */ 89 87 … … 94 92 95 93 /** 96 * \ingroup Utils 94 * \ingroup HighLevel_Misc 95 * \brief Closes down OpenPGP::SDK. 97 96 * 98 97 * Close down OpenPGP:SDK, release any resources under the control of … … 152 151 } 153 152 153 /** 154 \ingroup HighLevel_Misc 155 \brief mallocs and zeros memory 156 \param n Number of bytes to be alloc-ed. 157 \return Pointer to new memory. 158 \note Should be freed after use with free(). 159 */ 154 160 void *ops_mallocz(size_t n) 155 161 {
