Changeset 707

Timestamp:

05/15/12 12:25:47

Author:

ben

Message:

Fixes from Cyril Soler.

Files:

• openpgpsdk/trunk/CHANGES (modified) (1 diff)
• openpgpsdk/trunk/include/openpgpsdk/crypto.h (modified) (2 diffs)
• openpgpsdk/trunk/include/openpgpsdk/keyring.h (modified) (4 diffs)
• openpgpsdk/trunk/include/openpgpsdk/packet.h (modified) (5 diffs)
• openpgpsdk/trunk/include/openpgpsdk/signature.h (modified) (1 diff)
• openpgpsdk/trunk/include/openpgpsdk/types.h (modified) (5 diffs)
• openpgpsdk/trunk/include/openpgpsdk/validate.h (modified) (2 diffs)
• openpgpsdk/trunk/src/lib/create.c (modified) (3 diffs)
• openpgpsdk/trunk/src/lib/crypto.c (modified) (3 diffs)
• openpgpsdk/trunk/src/lib/keyring.c (modified) (6 diffs)
• openpgpsdk/trunk/src/lib/openssl_crypto.c (modified) (1 diff)
• openpgpsdk/trunk/src/lib/packet-parse.c (modified) (6 diffs)
• openpgpsdk/trunk/src/lib/reader_armoured.c (modified) (3 diffs)
• openpgpsdk/trunk/src/lib/readerwriter.c (modified) (3 diffs)
• openpgpsdk/trunk/src/lib/signature.c (modified) (4 diffs)
• openpgpsdk/trunk/src/lib/validate.c (modified) (32 diffs)
• openpgpsdk/trunk/src/lib/writer_armour.c (modified) (2 diffs)
• openpgpsdk/trunk/tests/test_dsa_signature.c (modified) (1 diff)
• openpgpsdk/trunk/tests/test_rsa_signature.c (modified) (1 diff)

openpgpsdk/trunk/CHANGES

@@ -1 +1 @@
-Changes since V0.9
-==================
+
+  *) Memory leak fixes and some bug fixes.
+     [Cyril Soler <cyril.soler@imag.fr>]
-
-  *) Various warnings from gcc 4.6 fixed.

openpgpsdk/trunk/include/openpgpsdk/crypto.h

@@ -156 +156 @@
-
-// Hash everything that's read
-
+ 
-void ops_reader_pop_hash(ops_parse_info_t *pinfo);
-
-
-
+
+
+
-ops_boolean_t ops_rsa_encrypt_mpi(const unsigned char *buf, const size_t buflen,
-    
-    
+       
+       
-
-
@@ -171 +172 @@
-                             const struct ops_key_data *key);
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-// Keys
-
-
+
+
+
+
+
-
-int ops_dsa_size(const ops_dsa_public_key_t *dsa);
-
+
+
+
-#endif

openpgpsdk/trunk/include/openpgpsdk/keyring.h

@@ -49 +49 @@
-                               const char* userid);
-void ops_keydata_free(ops_keydata_t *key);
+void ops_keydata_copy(ops_keydata_t *dst, const ops_keydata_t *src);
-void ops_keyring_free(ops_keyring_t *keyring);
-void ops_dump_keyring(const ops_keyring_t *keyring);
@@ -61 +62 @@
-                                                   const char *pphrase);
-
-
-
+
+
+
+
+
+
+
+
+
-
-char *ops_malloc_passphrase(char *passphrase);
@@ -69 +77 @@
-void ops_keyring_list(const ops_keyring_t* keyring);
-
-
+
+
-
-const unsigned char* ops_get_key_id(const ops_keydata_t *key);
@@ -75 +84 @@
-const unsigned char* ops_get_user_id(const ops_keydata_t *key, unsigned index);
-ops_boolean_t ops_is_key_supported(const ops_keydata_t *key);
-
+
+
-
-
-
-
+
+
+
+
+
+
+
-
-
+
+
-
-ops_keydata_t *ops_keydata_new(void);
-* 
+ *
-
-#endif

openpgpsdk/trunk/include/openpgpsdk/packet.h

@@ -126 +126 @@
- */
-#define OPS_PTAG_NF_CONTENT_TAG_SHIFT   0
-
-
-
-
@@ -698 +696 @@
-    {
-    unsigned                    length;
-data[8192]
+*data
-    } ops_literal_data_body_t;
-
@@ -744 +742 @@
-    {
-    unsigned                    length;
-data[8192]; // \todo fix hard-coded value?
+*data;
-    } ops_signed_cleartext_body_t;
-
@@ -916 +914 @@
-void ops_keyid(unsigned char keyid[OPS_KEY_ID_SIZE],
-               const ops_public_key_t *key);
-
+ 
-void ops_public_key_free(ops_public_key_t *key);
+void ops_public_key_copy(ops_public_key_t *dst, const ops_public_key_t *src);
-void ops_user_id_free(ops_user_id_t *id);
-void ops_user_attribute_free(ops_user_attribute_t *att);
@@ -941 +940 @@
-void ops_parser_content_free(ops_parser_content_t *c);
-void ops_secret_key_free(ops_secret_key_t *key);
+void ops_secret_key_copy(ops_secret_key_t *dst, const ops_secret_key_t *src);
-void ops_pk_session_key_free(ops_pk_session_key_t *sk);
-

openpgpsdk/trunk/include/openpgpsdk/signature.h

@@ -88 +88 @@
-
-// Standard Interface
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-#endif

openpgpsdk/trunk/include/openpgpsdk/types.h

@@ -43 +43 @@
-typedef unsigned ops_boolean_t;
-
+/** ops_content_tag_t */
+
-/* PTag Content Tags */
-/***************************/
@@ -53 +55 @@
- * \see RFC4880 5.2.3.1
- */
+
+#ifndef __cplusplus
+typedef enum ops_content_tag_t ops_content_tag_t ;
+#endif
+
-enum ops_content_tag_t
-    {
@@ -146 +153 @@
-    OPS_PARSER_CMD_GET_SK_PASSPHRASE    =0x400,
-    OPS_PARSER_CMD_GET_SECRET_KEY       =0x400+1,
+    OPS_PARSER_CMD_GET_SK_PASSPHRASE_PREV_WAS_BAD =0x400+2,
-
-
@@ -153 +161 @@
-    };
-
-
-
+
+
+
+
+
+
+
+
+
-
-typedef struct _ops_crypt_t ops_crypt_t;
@@ -179 +194 @@
-/** Used to specify whether subpackets should be returned raw, parsed or ignored.
- */
-enum ops_parse_type_t
-    {
-    OPS_PARSE_RAW,      /*!< Callback Raw */
-    OPS_PARSE_PARSED,   /*!< Callback Parsed */
-    OPS_PARSE_IGNORE,   /*!< Don't callback */
-    };
-
-typedef enum ops_parse_type_t ops_parse_type_t;

openpgpsdk/trunk/include/openpgpsdk/validate.h

@@ -79 +79 @@
-        SIGNED_CLEARTEXT
-        } use; /*<! this is set to indicate what kind of data we have */
+
-    union
-
-
-
-
+
+
+
+
+
-    unsigned char hash[OPS_MAX_HASH_SIZE]; /*<! the hash */
-    const ops_keyring_t *keyring; /*<! keyring to use */
@@ -99 +101 @@
-ops_boolean_t ops_validate_file(ops_validate_result_t* result, const char* filename, const int armoured, const ops_keyring_t* keyring);
-ops_boolean_t ops_validate_mem(ops_validate_result_t *result, ops_memory_t* mem, const int armoured, const ops_keyring_t* keyring);
-
-
+

openpgpsdk/trunk/src/lib/create.c

@@ -129 +129 @@
-
-    default:
+        fprintf(stderr,"Bad algorithm type in key: %d\n",key->algorithm) ;
-        assert(!"unknown key algorithm");
-        }
@@ -383 +384 @@
-           || !ops_write_mpi(key->key.rsa.q,info)
-           || !ops_write_mpi(key->key.rsa.u,info))
-    
-    
-
+       
+       
+
-            return ops_false;
-    
+       
-
-        break;
@@ -403 +404 @@
-
-    ops_writer_pop(info);
-
+
+
+
+
-    return ops_true;
-
+   
-
-

openpgpsdk/trunk/src/lib/crypto.c

@@ -180 +180 @@
-
-    ops_create_info_t *cinfo;
-
+
-    fd_in=open(input_filename, O_RDONLY | O_BINARY);
+#else
+    fd_in=open(input_filename, O_RDONLY );
+#endif
-    if(fd_in < 0)
-        {
@@ -265 +268 @@
-    else
-        ops_writer_push_literal(cinfo);
+    }
+
+/**
+   \ingroup HighLevel_Crypto
+   \brief Decrypt a chunk of memory, containing a encrypted stream.
+   \param input_filename Name of file to be decrypted
+   \param output_filename Name of file to write to. If NULL, the filename is constructed from the input filename, following GPG conventions.
+   \param keyring Keyring to use
+   \param use_armour Expect armoured text, if set
+   \param allow_overwrite Allow output file to overwritten, if set.
+   \param cb_get_passphrase Callback to use to get passphrase
+*/
+
+ops_boolean_t ops_decrypt_memory(const unsigned char *encrypted_memory,
+                                 int em_length,
+                                 unsigned char **decrypted_memory,
+                                 int *out_length, ops_keyring_t *keyring,
+                                 const ops_boolean_t use_armour,
+                                 ops_parse_cb_t *cb_get_passphrase)
+    {
+
+    //
+    ops_parse_info_t *pinfo=NULL;
+
+    // setup for reading from given input file
+
+    ops_memory_t *input_mem = ops_memory_new() ;
+    ops_memory_add(input_mem,encrypted_memory,em_length) ;
+
+    ops_setup_memory_read(&pinfo, input_mem, NULL, callback_write_parsed,
+                          ops_false);
+
+    if (pinfo == NULL)
+         {
+         perror("cannot create memory read");
+         return ops_false;
+         }
+
+    // setup memory chunk 
+
+    ops_memory_t *output_mem = ops_memory_new() ;
+
+    ops_setup_memory_write(&pinfo->cbinfo.cinfo, &output_mem,0) ;
+
+    if (output_mem == NULL)
+        { 
+        perror("Cannot create output memory"); 
+        ops_teardown_memory_read(pinfo, input_mem);
+        return ops_false;
+        }
+
+    // \todo check for suffix matching armour param
+
+    // setup keyring and passphrase callback
+    pinfo->cbinfo.cryptinfo.keyring=keyring;
+    pinfo->cbinfo.cryptinfo.cb_get_passphrase=cb_get_passphrase;
+
+    // Set up armour/passphrase options
+
+    if (use_armour)
+        ops_reader_push_dearmour(pinfo);
+    
+    // Do it
+
+    ops_parse_and_print_errors(pinfo);
+
+    // Unsetup
+
+    if (use_armour)
+        ops_reader_pop_dearmour(pinfo);
+
+    ops_boolean_t res = ops_true;
+
+    // copy output memory to supplied buffer.
+    //
+    *out_length = ops_memory_get_length(output_mem);
+    *decrypted_memory = ops_mallocz(*out_length);
+    memcpy(*decrypted_memory, ops_memory_get_data(output_mem), *out_length);
+
+    ops_teardown_memory_write(pinfo->cbinfo.cinfo, output_mem);
+    ops_teardown_memory_read(pinfo, input_mem);
+
+    return res;
-    }
-
@@ -420 +506 @@
-
-    case OPS_PARSER_CMD_GET_SK_PASSPHRASE:
+    case OPS_PARSER_CMD_GET_SK_PASSPHRASE_PREV_WAS_BAD:
-        //        return callback_cmd_get_secret_key_passphrase(content_,cbinfo);
-        return cbinfo->cryptinfo.cb_get_passphrase(content_, cbinfo);

openpgpsdk/trunk/src/lib/keyring.c

@@ -79 +79 @@
-    keydata->npackets=0;
-
+    free(keydata->sigs);
+
-    if(keydata->type == OPS_PTAG_CT_PUBLIC_KEY)
-        ops_public_key_free(&keydata->key.pkey);
-    else
-        ops_secret_key_free(&keydata->key.skey);
-
-    }
-
@@ -101 +102 @@
-    free(keydata);
-    }
+
+// \todo check where userid pointers are copied
+/**
+\ingroup Core_Keys
+\brief Copy user id, including contents
+\param dst Destination User ID
+\param src Source User ID
+\note If dst already has a user_id, it will be freed.
+*/
+void ops_copy_userid(ops_user_id_t* dst, const ops_user_id_t* src)
+    {
+    int len=strlen((char *)src->user_id);
+    if (dst->user_id)
+        free(dst->user_id);
+    dst->user_id=ops_mallocz(len+1);
+
+    memcpy(dst->user_id, src->user_id, len);
+    }
+// \todo check where pkt pointers are copied
+/**
+\ingroup Core_Keys
+\brief Copy packet, including contents
+\param dst Destination packet
+\param src Source packet
+\note If dst already has a packet, it will be freed.
+*/
+void ops_copy_packet(ops_packet_t* dst, const ops_packet_t* src)
+    {
+    if (dst->raw)
+        free(dst->raw);
+    dst->raw=ops_mallocz(src->length);
+
+    dst->length=src->length;
+    memcpy(dst->raw, src->raw, src->length);
+    }
+
+
+
+/**
+\ingroup Core_Keys
+\brief Copies entire key data
+\param dst Destination key where to copy
+\param src Source key to copy
+*/
+void ops_keydata_copy(ops_keydata_t *dst,const ops_keydata_t *src)
+    {
+    unsigned n;
+
+    memset(dst, 0, sizeof(ops_keydata_t));
+
+    dst->uids = (ops_user_id_t*)ops_mallocz(src->nuids * sizeof(ops_user_id_t));
+    dst->nuids = src->nuids;
+    dst->nuids_allocated = src->nuids;
+
+    for(n=0 ; n < src->nuids ; ++n)
+        ops_copy_userid(&dst->uids[n],&src->uids[n]);
+
+    dst->packets = (ops_packet_t*)ops_mallocz(src->npackets * sizeof(ops_packet_t));
+    dst->npackets = src->npackets;
+    dst->npackets_allocated = src->npackets;
+
+    for(n=0 ; n < src->npackets ; ++n)
+        ops_copy_packet(&(dst->packets[n]),&(src->packets[n]));
+
+    dst->nsigs = src->nsigs;
+    dst->sigs = (sigpacket_t*)ops_mallocz(src->nsigs * sizeof(sigpacket_t));
+    dst->nsigs_allocated = src->nsigs;
+
+    for(n=0 ; n < src->nsigs ; ++n)
+        {
+        dst->sigs[n].userid = (ops_user_id_t*)ops_mallocz(sizeof(ops_user_id_t));
+        dst->sigs[n].packet = (ops_packet_t*)ops_mallocz(sizeof(ops_packet_t));
+        ops_copy_userid(dst->sigs[n].userid,src->sigs[n].userid);
+        ops_copy_packet(dst->sigs[n].packet,src->sigs[n].packet);
+        }
+
+    dst->key_id[0] = src->key_id[0];
+    dst->key_id[1] = src->key_id[1];
+    dst->key_id[2] = src->key_id[2];
+    dst->key_id[3] = src->key_id[3];
+    dst->key_id[4] = src->key_id[4];
+    dst->key_id[5] = src->key_id[5];
+    dst->key_id[6] = src->key_id[6];
+    dst->key_id[7] = src->key_id[7];
+    dst->type = src->type;
+    dst->key = src->key;
+    dst->fingerprint = src->fingerprint;
+
+    if(src->type == OPS_PTAG_CT_PUBLIC_KEY)
+        ops_public_key_copy(&dst->key.pkey,&src->key.pkey);
+    else                  
+        ops_secret_key_copy(&dst->key.skey,&src->key.skey);
+    }
+
-
-/**
@@ -267 +362 @@
-    ops_parse(pinfo);
-
+    ops_parse_info_delete(pinfo);
+
-    return arg.skey;
-    }
@@ -363 +460 @@
-        return NULL;
-    return &keyring->keys[index]; 
-    }
-
-// \todo check where userid pointers are copied
-/**
-\ingroup Core_Keys
-\brief Copy user id, including contents
-\param dst Destination User ID
-\param src Source User ID
-\note If dst already has a user_id, it will be freed.
-*/
-void ops_copy_userid(ops_user_id_t* dst, const ops_user_id_t* src)
-    {
-    int len=strlen((char *)src->user_id);
-    if (dst->user_id)
-        free(dst->user_id);
-    dst->user_id=ops_mallocz(len+1);
-
-    memcpy(dst->user_id, src->user_id, len);
-    }
-
-// \todo check where pkt pointers are copied
-/**
-\ingroup Core_Keys
-\brief Copy packet, including contents
-\param dst Destination packet
-\param src Source packet
-\note If dst already has a packet, it will be freed.
-*/
-void ops_copy_packet(ops_packet_t* dst, const ops_packet_t* src)
-    {
-    if (dst->raw)
-        free(dst->raw);
-    dst->raw=ops_mallocz(src->length);
-
-    dst->length=src->length;
-    memcpy(dst->raw, src->raw, src->length);
-    }
-
@@ -624 +685 @@
-    //    ops_parse_options(pinfo,OPS_PTAG_SS_ALL,OPS_PARSE_RAW);
-    ops_parse_options(pinfo,OPS_PTAG_SS_ALL,OPS_PARSE_PARSED);
-
-    fd=open(filename,O_RDONLY | O_BINARY);
-    if(fd < 0)
@@ -907 +967 @@
-    }
-
+/**
+   \ingroup HighLevel_KeyringList
+
+   \brief Saves keyring to specified file
+
+   \param keyring  Keyring to save
+   \param armoured Save in ascii armoured format
+   \param output filename
+
+   \return ops_true is anything when ok
+*/
+
+ops_boolean_t ops_write_keyring_to_file(const ops_keyring_t *keyring,ops_boolean_t armoured,const char *filename)
+    {
+    ops_create_info_t *info;
+    int fd = ops_setup_file_write(&info, filename, ops_true);
+
+    if (fd < 0) 
+        {
+        fprintf(stderr,"ops_write_keyring(): ERROR: Cannot write to %s\n",
+                filename);
+        return ops_false;
+        }
+
+    int i;
+    for(i=0 ; i<keyring->nkeys ; ++i)
+        if(keyring->keys[i].key.pkey.algorithm  == OPS_PKA_RSA)
+            ops_write_transferable_public_key(&keyring->keys[i],armoured,info);
+        else
+            {
+            fprintf(stdout, "ops_write_keyring: not writing key. Algorithm not handled: ");
+            ops_print_public_keydata(&keyring->keys[i]);
+            fprintf(stdout, "\n");
+            }
+
+    ops_writer_close(info);
+    ops_create_info_delete(info);
+
+    return ops_true;
+    }
+
-/*\@}*/
-

openpgpsdk/trunk/src/lib/openssl_crypto.c

@@ -747 +747 @@
-        {
-        ops_keydata_free(keydata);
+        free(keydata);
-        return NULL;
-        }

openpgpsdk/trunk/src/lib/packet-parse.c

@@ -922 +922 @@
-
-    case OPS_PARSER_CMD_GET_SK_PASSPHRASE:
+    case OPS_PARSER_CMD_GET_SK_PASSPHRASE_PREV_WAS_BAD:
-        ops_cmd_get_passphrase_free(&c->content.secret_key_passphrase);
-        break;
@@ -998 +999 @@
-    }
-
+void ops_public_key_copy(ops_public_key_t *dst,const ops_public_key_t *src)
+    {
+    *dst = *src ;
+
+    switch(src->algorithm)
+        {
+    case OPS_PKA_RSA:
+    case OPS_PKA_RSA_ENCRYPT_ONLY:
+    case OPS_PKA_RSA_SIGN_ONLY:
+        dst->key.rsa.n = BN_dup(src->key.rsa.n);
+        dst->key.rsa.e = BN_dup(src->key.rsa.e);
+        break;
+
+    case OPS_PKA_DSA:
+        dst->key.dsa.p = BN_dup(src->key.dsa.p);
+        dst->key.dsa.q = BN_dup(src->key.dsa.q);
+        dst->key.dsa.g = BN_dup(src->key.dsa.g);
+        dst->key.dsa.y = BN_dup(src->key.dsa.y);
+        break;
+
+    case OPS_PKA_ELGAMAL:
+    case OPS_PKA_ELGAMAL_ENCRYPT_OR_SIGN:
+        dst->key.elgamal.p = BN_dup(src->key.elgamal.p);
+        dst->key.elgamal.g = BN_dup(src->key.elgamal.g);
+        dst->key.elgamal.y = BN_dup(src->key.elgamal.y);
+        break;
+
+        //case 0:
+        // nothing to free
+        //   break;
+
+    default:
+        assert(0);
+        }
+    }
+
+
-/**
-   \ingroup Core_ReadPackets
-*/
-
+ 
-                                 ops_parse_info_t *pinfo)
-    {
@@ -1214 +1252 @@
-
-    CBP(pinfo,OPS_PTAG_CT_USER_ID,&content);
+
-    return 1;
-    }
@@ -2073 +2112 @@
-        unsigned l=region->length-region->length_read;
-
-
-
+
-
-        if(!limited_read(C.literal_data_body.data,l,region,pinfo))
@@ -2121 +2159 @@
-
-    ops_public_key_free(&key->public_key);
+    }
+
+void ops_secret_key_copy(ops_secret_key_t *dst,const ops_secret_key_t *src)
+    {
+    *dst = *src ;
+    ops_public_key_copy(&dst->public_key,&src->public_key);
+
+    switch(src->public_key.algorithm)
+        {
+    case OPS_PKA_RSA:
+    case OPS_PKA_RSA_ENCRYPT_ONLY:
+    case OPS_PKA_RSA_SIGN_ONLY:
+        dst->key.rsa.d = BN_dup(src->key.rsa.d) ;
+        dst->key.rsa.p = BN_dup(src->key.rsa.p) ;
+        dst->key.rsa.q = BN_dup(src->key.rsa.q) ;
+        dst->key.rsa.u = BN_dup(src->key.rsa.u) ;
+        break;
+
+    case OPS_PKA_DSA:
+        dst->key.dsa.x = BN_dup(src->key.dsa.x) ;
+        break;
+
+    default:
+        fprintf(stderr,"ops_secret_key_copy: Unknown algorithm: %d (%s)\n",
+                src->public_key.algorithm,
+                ops_show_pka(src->public_key.algorithm));
+        //assert(0);
+        }
-    }
-
@@ -2970 +3036 @@
-        pinfo->rinfo.asize=0;
-        }
+    else
+       C.packet.raw = NULL ;
+
-    pinfo->rinfo.alength=0;
-        

openpgpsdk/trunk/src/lib/reader_armoured.c

@@ -388 +388 @@
-    hash->init(hash);
-
+#define BODYSIZE 4096
+    body->data = malloc(BODYSIZE);
-    body->length=0;
-    total=0;
@@ -434 +436 @@
-        body->data[body->length++]=c;
-        ++total;
-sizeof body->data
+BODYSIZE
-            {
-            if (debug)
@@ -446 +448 @@
-    assert(body->length == 1);
-    /* don't send that one character, because its part of the trailer. */
+
+    free(body->data);
-
-    trailer->hash=hash;

openpgpsdk/trunk/src/lib/readerwriter.c

@@ -338 +338 @@
-
-ops_parse_cb_return_t
-
-
-
+
+
+
+
-    const ops_secret_key_t *secret;
-    ops_parser_content_t pc;
-
-    OPS_USED(cbinfo);
-
-//    ops_print_packet(content_);
-
-    switch(content_->tag)
-        {
-    case OPS_PARSER_CMD_GET_SECRET_KEY:
-
-
+
+
+
+
+
-            return 0;
-
-        /* now get the key from the data */
-        secret=ops_get_secret_key_from_data(cbinfo->cryptinfo.keydata);
-
+
+
+
+
-            {
-            if (!cbinfo->cryptinfo.passphrase)
-                {
-                memset(&pc,'\0',sizeof pc);
-
-
+
+
+
-                if (!cbinfo->cryptinfo.passphrase)
-                    {
@@ -371 +377 @@
-                }
-            /* then it must be encrypted */
-
+
+
+
+
+
+
-            }
-
+
+
+
+
-        *content->get_secret_key.secret_key=secret;
-        break;
@@ -381 +395 @@
-        break;
-        }
-
+
-    return OPS_RELEASE_MEMORY;
-    }

openpgpsdk/trunk/src/lib/signature.c

@@ -1234 +1234 @@
-\param skey Secret Key
-\param use_armour Write armoured text, if set
+\param include_data Includes the signed data in the output message. If not, creates a detached signature.
-\return New ops_memory_t struct containing signed text
-\note It is the caller's responsibility to call ops_memory_free(me)
@@ -1263 +1264 @@
-                           const ops_sig_type_t sig_type,
-                           const ops_secret_key_t *skey,
-
+
+
-    {
-    // \todo allow choice of hash algorithams
@@ -1310 +1312 @@
-        fprintf(stderr,"** Writing out data now\n");
-
-
+
+
-
-    if (debug)
@@ -1331 +1334 @@
-    // tidy up
-    ops_writer_close(cinfo);
+         free(cinfo) ;
-    ops_create_signature_delete(sig);
-

openpgpsdk/trunk/src/lib/validate.c

@@ -77 +77 @@
-        trailer[5]=hashedlen;
-        hash.add(&hash,&trailer[0],6);
-
+
-        break;
-
@@ -92 +92 @@
-
-static int keydata_reader(void *dest,size_t length,ops_error_t **errors,
- 
- 
+
+
-    {
-    validate_reader_arg_t *arg=ops_reader_get_arg(rinfo);
@@ -123 +123 @@
-    }
-
-
+
+
-    {
-    memcpy(dst,src,sizeof *src);
-    dst->v4_hashed_data=ops_mallocz(src->v4_hashed_data_length);
-
-
-
-
+
+
+
+
+
+
-    {
-    size_t newsize;
-    size_t start;
-
-    // increment count
@@ -146 +148 @@
-
-    // copy key ptr to array
-start=(sizeof *sig) * (result->valid_count-1
-copy_signature_info(result->valid_sigs+start,sig);
-
-
-static void add_sig_to_invalid_list(ops_validate_result_t * result,
+copy_signature_info(&result->valid_sigs[result->valid_count-1], sig
+}
+
+
+                                  
-    {
-    size_t newsize;
-    size_t start;
-
-    // increment count
@@ -166 +167 @@
-
-    // copy key ptr to array
-start=(sizeof *sig) * (result->invalid_count-1
-copy_signature_info(result->invalid_sigs+start, sig);
-
-
-static void add_sig_to_unknown_list(ops_validate_result_t * result,
+copy_signature_info(&result->invalid_sigs[result->invalid_count-1], sig
+}
+
+
+                                  
-    {
-    size_t newsize;
-    size_t start;
-
-    // increment count
@@ -186 +186 @@
-
-    // copy key id to array
-start=OPS_KEY_ID_SIZE * (result->unknown_signer_count-1);
-    copy_signature_info(result->unknown_sigs+start, 
+copy_signature_info(&result->unknown_sigs[result->unknown_signer_count-1],
+                       
-    }
-
-ops_parse_cb_return_t
-
+
+
-    {
-    const ops_parser_content_union_t *content=&content_->content;
@@ -208 +209 @@
-        arg->pkey=content->public_key;
-        return OPS_KEEP_MEMORY;
-
+
-    case OPS_PTAG_CT_PUBLIC_SUBKEY:
-        if(arg->subkey.version)
@@ -214 +215 @@
-        arg->subkey=content->public_key;
-        return OPS_KEEP_MEMORY;
-
+
-    case OPS_PTAG_CT_SECRET_KEY:
-        arg->skey=content->secret_key;
@@ -271 +272 @@
-                                                                       ops_get_public_key_from_data(signer),
-                                                                       arg->rarg->key->packets[arg->rarg->packet].raw);
-
+
-            break;
-
@@ -341 +342 @@
-
-ops_parse_cb_return_t
-
+
+
-    {
-    const ops_parser_content_union_t *content=&content_->content;
@@ -364 +366 @@
-
-    case OPS_PTAG_CT_LITERAL_DATA_BODY:
-
+
+
+
-        arg->use=LITERAL_DATA;
-        return OPS_KEEP_MEMORY;
@@ -370 +374 @@
-
-    case OPS_PTAG_CT_SIGNED_CLEARTEXT_BODY:
-
+
+
+
-        arg->use=SIGNED_CLEARTEXT;
-        return OPS_KEEP_MEMORY;
@@ -381 +387 @@
-    case OPS_PTAG_CT_SIGNATURE: // V3 sigs
-    case OPS_PTAG_CT_SIGNATURE_FOOTER: // V4 sigs
-
+
-        if (debug)
-            {
@@ -402 +408 @@
-            break;
-            }
-
+
-        mem=ops_memory_new();
-        ops_memory_init(mem,128);
-
+
-        switch(content->signature.info.type)
-            {
@@ -414 +420 @@
-            case LITERAL_DATA:
-                ops_memory_add(mem,
-                        
-                        
+                       
+                       
-                break;
-
+
-            case SIGNED_CLEARTEXT:
-                ops_memory_add(mem,
-                        
-                        
+                       
+                       
-                break;
-
+
-            default:
-                OPS_ERROR_1(errors,OPS_E_UNIMPLEMENTED,"Unimplemented Sig Use %d", arg->use);
@@ -429 +435 @@
-                break;
-                }
-
+
-            valid=check_binary_signature(ops_memory_get_length(mem), 
-                                         ops_memory_get_data(mem),
@@ -440 +446 @@
-                        "Verification of signature type 0x%02x not yet implemented\n", content->signature.info.type);
-            break;
-
+
-            }
-    
+       
-
-        if(valid)
-
-
-
+
-        else
-            {
-    
-    
+       
+       
-            }
-        break;
@@ -496 +500 @@
-ops_boolean_t validate_result_status(ops_validate_result_t* result)
-    {
-
+
+
-        return ops_false;
-    else
@@ -512 +517 @@
- * \note It is the caller's responsiblity to free result after use.
- * \sa ops_validate_result_free()
-
+
- Example Code:
-
-
-
+ 
+ 
+ 
-  ops_validate_result_t *result=NULL;
-  if (ops_validate_key_signatures(result, key, keyring, callback_cmd_get_passphrase_from_cmdline)==ops_true)
@@ -527 +532 @@
-         result->unknown_signer_count);
-  ops_validate_result_free(result);
-
-
-
+ 
+
+ 
- */
-ops_boolean_t ops_validate_key_signatures(ops_validate_result_t *result,const ops_keydata_t *key,
@@ -566 +571 @@
-    ops_parse_info_delete(pinfo);
-
-
+
+
-        return ops_false;
-    else
@@ -579 +585 @@
-   \note It is the caller's responsibility to free result after use.
-   \sa ops_validate_result_free()
-
+ 
-ops_boolean_t ops_validate_all_signatures(ops_validate_result_t *result,
-                                 const ops_keyring_t *ring,
@@ -589 +595 @@
-    memset(result,'\0',sizeof *result);
-    for(n=0 ; n < ring->nkeys ; ++n)
-
+
+
-    return validate_result_status(result);
-    }
@@ -598 +605 @@
-   \param result Struct to be freed
-   \note Must be called after validation functions
-
+ 
-void ops_validate_result_free(ops_validate_result_t *result)
-    {
@@ -627 +634 @@
-   \note It is the caller's responsiblity to call ops_validate_result_free(result) after use.
-
-
-
-
-
+  
+  
+  
+  
-  ops_validate_result_t* result=ops_mallocz(sizeof *result);
-
+
-  if (ops_validate_file(result, filename, armoured, keyring)==ops_true)
-  {
-    printf("OK");
-    
-  
-  
-  
-    
-    
-  
-
-  
+
+
+
+
+
+
+
+
+
-}
-\endcode
-
-
+
+
+
+
+
-    {
-    ops_parse_info_t *pinfo=NULL;
-    validate_data_cb_arg_t validate_arg;
-
-    int fd=0;
-
-//
-    fd=ops_setup_file_read(&pinfo, filename, &validate_arg, validate_data_cb,
+fd=ops_setup_file_read(&pinfo, filename, &validate_arg, validate_data_cb,
+                         
-    if (fd < 0)
-        return ops_false;
@@ -662 +671 @@
-    // Set verification reader and handling options
-
-'\0',
+ '\0', 
-    validate_arg.result=result;
-    validate_arg.keyring=keyring;
@@ -671 +680 @@
-    if (armoured)
-        ops_reader_push_dearmour(pinfo);
-
+
-    // Do the verification
-
@@ -688 +697 @@
-        ops_reader_pop_dearmour(pinfo);
-    ops_teardown_file_read(pinfo, fd);
+
+    if(validate_arg.data.literal_data_body.data != NULL)
+        free(validate_arg.data.literal_data_body.data);
-
-    return validate_result_status(result);
@@ -703 +715 @@
-   have passed, failed and not been recognised.
-   \note It is the caller's responsiblity to call ops_validate_result_free(result) after use.
-
+ 
-
-ops_boolean_t ops_validate_mem(ops_validate_result_t *result, ops_memory_t* mem, const int armoured, const ops_keyring_t* keyring)
@@ -710 +722 @@
-    validate_data_cb_arg_t validate_arg;
-
-    //
-    ops_setup_memory_read(&pinfo, mem, &validate_arg, validate_data_cb, ops_true);
-
-    // Set verification reader and handling options
-
-'\0',
+ '\0', 
-    validate_arg.result=result;
-    validate_arg.keyring=keyring;
@@ -724 +735 @@
-    if (armoured)
-        ops_reader_push_dearmour(pinfo);
-
+
-    // Do the verification
-
@@ -742 +753 @@
-    ops_teardown_memory_read(pinfo, mem);
-
+    if(validate_arg.data.literal_data_body.data != NULL)
+        free(validate_arg.data.literal_data_body.data);
+
-    return validate_result_status(result);
-    }
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

openpgpsdk/trunk/src/lib/writer_armour.c

@@ -35 +35 @@
-static int debug=0;
-
-75
+63
-
-static const char newline[] = "\r\n";
@@ -285 +285 @@
-    } linebreak_arg_t;
-
-76
+64
-
-static ops_boolean_t linebreak_writer(const unsigned char *src,

openpgpsdk/trunk/tests/test_dsa_signature.c

@@ -173 +173 @@
-    validate_data_cb_arg_t validate_arg;
-
-
+
+
-
-    if (debug)

openpgpsdk/trunk/tests/test_rsa_signature.c

@@ -207 +207 @@
-    validate_data_cb_arg_t validate_arg;
-
-
+
+
-
-    /*