root/openpgpsdk/trunk/tests/test_rsa_signature.c

#include "CUnit/Basic.h"

#include <openpgpsdk/types.h>
#include "openpgpsdk/keyring.h"
#include <openpgpsdk/armour.h>
#include "openpgpsdk/packet.h"
#include "openpgpsdk/packet-parse.h"
#include "openpgpsdk/packet-show.h"
#include "openpgpsdk/util.h"
#include "openpgpsdk/std_print.h"
#include "openpgpsdk/readerwriter.h"
#include "openpgpsdk/validate.h"

#include "tests.h"

static int do_gpgtest=0;

static char *filename_rsa_noarmour_nopassphrase="ops_rsa_signed_noarmour_nopassphrase.txt";
static char *filename_rsa_noarmour_passphrase="ops_rsa_signed_noarmour_passphrase.txt";
static char *filename_rsa_armour_nopassphrase="ops_rsa_signed_armour_nopassphrase.txt";
static char *filename_rsa_armour_passphrase="ops_rsa_signed_armour_passphrase.txt";

static ops_parse_cb_return_t
callback_verify(const ops_parser_content_t *content_,ops_parse_cb_info_t *cbinfo);

/* Signature suite initialization.
 * Create temporary directory.
 * Create temporary test files.
 */

int init_suite_rsa_signature(void)
    {
    do_gpgtest=0;

    // Create test files

    create_testfile(filename_rsa_noarmour_nopassphrase);
    create_testfile(filename_rsa_noarmour_passphrase);
    create_testfile(filename_rsa_armour_nopassphrase);
    create_testfile(filename_rsa_armour_passphrase);

    // Return success
    return 0;
    }

int init_suite_rsa_signature_gpgtest(void)
    {
    init_suite_rsa_signature();

    do_gpgtest=1;

    return 0;
    }

int clean_suite_rsa_signature(void)
    {
    ops_finish();

    reset_vars();

    return 0;
    }

static void test_rsa_signature(const int has_armour, const char *filename, const ops_secret_key_t *skey, ops_hash_algorithm_t hash_alg)
    {
    unsigned char keyid[OPS_KEY_ID_SIZE];
    ops_create_signature_t *sig=NULL;

    char cmd[MAXBUF+1];
    char myfile[MAXBUF+1];
    char signed_file[MAXBUF+1];
    char *suffix= has_armour ? "asc" : "gpg";
    int fd_in=0;
    int fd_out=0;
    int rtn=0;
    ops_create_info_t *cinfo=NULL;
    
    // open file to sign
    snprintf(myfile,MAXBUF,"%s/%s",dir,filename);
#ifdef WIN32
    fd_in=open(myfile,O_RDONLY | O_BINARY);
#else
    fd_in=open(myfile,O_RDONLY);
#endif
    if(fd_in < 0)
        {
        perror(myfile);
        exit(2);
        }
    
    snprintf(signed_file,MAXBUF,"%s/%s_%s.%s",dir,filename,ops_show_hash_algorithm(hash_alg),suffix);
#ifdef WIN32
    fd_out=open(signed_file,O_WRONLY | O_CREAT | O_EXCL | O_BINARY, 0600);
#else
    fd_out=open(signed_file,O_WRONLY | O_CREAT | O_EXCL, 0600);
#endif
    if(fd_out < 0)
        {
        perror(signed_file);
        exit(2);
        }
    
    // Set up armour/passphrase options
    // OPS code armours signatures by default

    assert(has_armour);
    
    // set up signature
    sig=ops_create_signature_new();
    ops_signature_start_plaintext_signature(sig,(ops_secret_key_t *)skey,hash_alg,OPS_SIG_BINARY);

    // set up output file
    cinfo=ops_create_info_new();
    ops_writer_set_fd(cinfo,fd_out); 
    ops_writer_push_dash_escaped(cinfo,sig);

    // Do the signing

    for (;;)
        {
        unsigned char buf[MAXBUF];
        int n=0;
    
        n=read(fd_in,buf,sizeof(buf));
        if (!n)
            break;
        assert(n>=0);
        ops_write(buf,n,cinfo);
        }
    close(fd_in);

    // add signature

    ops_writer_switch_to_signature(cinfo);
    ops_signature_add_creation_time(sig,time(NULL));
    ops_keyid(keyid,&skey->public_key);
    ops_signature_add_issuer_key_id(sig,keyid);
    ops_signature_hashed_subpackets_end(sig);
    ops_write_signature(sig,(ops_public_key_t *)&skey->public_key,(ops_secret_key_t *)skey,cinfo);
    ops_writer_close(cinfo);
    close(fd_out);

    // Check

    if (!do_gpgtest)
        {
        int fd=0;
        ops_parse_info_t *pinfo=NULL;
        validate_cb_arg_t validate_arg;
        ops_validate_result_t result;
        int rtn=0;

    // open signed file
#ifdef WIN32
        fd=open(signed_file,O_RDONLY | O_BINARY);
#else
        fd=open(signed_file,O_RDONLY);
#endif
        if(fd < 0)
            {
            perror(signed_file);
            exit(2);
            }
        
        // Set verification reader and handling options
        
        pinfo=ops_parse_info_new();
        ops_parse_cb_set(pinfo,callback_verify,&validate_arg);
        ops_reader_set_fd(pinfo,fd);
        
        memset(&validate_arg,'\0',sizeof validate_arg);
        validate_arg.result=&result;
        validate_arg.keyring=&pub_keyring;
        validate_arg.rarg=ops_reader_get_arg_from_pinfo(pinfo);
        
        // Set up armour/passphrase options
        
        if (has_armour)
            ops_reader_push_dearmour(pinfo,ops_false,ops_false,ops_false);
        //    current_passphrase=has_passphrase ? passphrase : nopassphrase;
        
        // Do the verification
        
        rtn=ops_parse(pinfo);
        ops_print_errors(ops_parse_info_get_errors(pinfo));
        CU_ASSERT(rtn==1);
        
        // Tidy up
        if (has_armour)
            ops_reader_pop_dearmour(pinfo);
        
        ops_public_key_free(&validate_arg.pkey);
        if (validate_arg.subkey.version)
            ops_public_key_free(&validate_arg.subkey);
        ops_user_id_free(&validate_arg.user_id);
        ops_user_attribute_free(&validate_arg.user_attribute);
        ops_parse_info_delete(pinfo);
        
        close(fd);
        }
    else
        {
        // Check signature with GPG

        snprintf(cmd,MAXBUF,"gpg --verify --quiet --homedir %s %s", dir, signed_file);
        rtn=system(cmd);
        CU_ASSERT(rtn==0);
        }
    }

void test_rsa_signature_noarmour_nopassphrase(void)
    {
    int armour=0;
    assert(pub_keyring.nkeys);
    test_rsa_signature(armour,filename_rsa_noarmour_nopassphrase, alpha_skey, OPS_HASH_SHA1);
#ifdef TODO
    test_rsa_signature(armour,filename_rsa_noarmour_nopassphrase, alpha_skey, OPS_HASH_MD5);
    test_rsa_signature(armour,filename_rsa_noarmour_nopassphrase, alpha_skey, OPS_HASH_RIPEMD);
    test_rsa_signature(armour,filename_rsa_noarmour_nopassphrase, alpha_skey, OPS_HASH_SHA256);
    test_rsa_signature(armour,filename_rsa_noarmour_nopassphrase, alpha_skey, OPS_HASH_SHA384);
    test_rsa_signature(armour,filename_rsa_noarmour_nopassphrase, alpha_skey, OPS_HASH_SHA512);
#endif
    }

void test_rsa_signature_noarmour_passphrase(void)
    {
    int armour=0;
    assert(pub_keyring.nkeys);
    test_rsa_signature(armour,filename_rsa_noarmour_passphrase, bravo_skey, OPS_HASH_SHA1);
    }

void test_rsa_signature_armour_nopassphrase(void)
    {
    int armour=1;
    assert(pub_keyring.nkeys);
    test_rsa_signature(armour,filename_rsa_armour_nopassphrase, alpha_skey, OPS_HASH_SHA1);
    }

void test_rsa_signature_armour_passphrase(void)
    {
    int armour=1;
    assert(pub_keyring.nkeys);
    test_rsa_signature(armour,filename_rsa_armour_passphrase, bravo_skey, OPS_HASH_SHA1);
    }

CU_pSuite suite_rsa_signature()
{
    CU_pSuite suite = NULL;

    suite = CU_add_suite("RSA Signature Suite", init_suite_rsa_signature, clean_suite_rsa_signature);
    if (!suite)
            return NULL;

    // add tests to suite
    
#ifdef TBD
    if (NULL == CU_add_test(suite, "Unarmoured, no passphrase", test_rsa_signature_noarmour_nopassphrase))
            return NULL;
    
    if (NULL == CU_add_test(suite, "Unarmoured, passphrase", test_rsa_signature_noarmour_passphrase))
            return NULL;
#endif /*TBD*/
    
    if (NULL == CU_add_test(suite, "Armoured, no passphrase", test_rsa_signature_armour_nopassphrase))
            return NULL;
    
    if (NULL == CU_add_test(suite, "Armoured, passphrase", test_rsa_signature_armour_passphrase))
            return NULL;
    
    
    return suite;
}

CU_pSuite suite_rsa_signature_GPGtest()
{
    CU_pSuite suite = NULL;

    suite = CU_add_suite("RSA Signature Suite (GPG interop)", init_suite_rsa_signature_gpgtest, clean_suite_rsa_signature);

    if (!suite)
            return NULL;

    // add tests to suite
    
#ifdef TBD
    if (NULL == CU_add_test(suite, "Unarmoured, no passphrase", test_rsa_signature_noarmour_nopassphrase))
            return NULL;
    
    if (NULL == CU_add_test(suite, "Unarmoured, passphrase", test_rsa_signature_noarmour_passphrase))
            return NULL;
#endif /*TBD*/
    
    if (NULL == CU_add_test(suite, "Armoured, no passphrase", test_rsa_signature_armour_nopassphrase))
            return NULL;
    
    if (NULL == CU_add_test(suite, "Armoured, passphrase", test_rsa_signature_armour_passphrase))
            return NULL;
    
    
    return suite;
}

static ops_parse_cb_return_t
callback_verify(const ops_parser_content_t *content_,ops_parse_cb_info_t *cbinfo)
    {
    //    ops_parser_content_union_t* content=(ops_parser_content_union_t *)&content_->content;

    //        ops_print_packet(content_);

    switch(content_->tag)
        {
    case OPS_PTAG_CT_LITERAL_DATA_HEADER:
        break;

    case OPS_PTAG_CT_LITERAL_DATA_BODY:
        return callback_literal_data(content_,cbinfo);
        break;

    case OPS_PTAG_CT_ONE_PASS_SIGNATURE:
 case OPS_PTAG_CT_SIGNATURE:
 case OPS_PTAG_CT_SIGNED_CLEARTEXT_HEADER:
 case OPS_PTAG_CT_SIGNED_CLEARTEXT_BODY:
 case OPS_PTAG_CT_SIGNED_CLEARTEXT_TRAILER:
 case OPS_PTAG_CT_ARMOUR_HEADER:
 case OPS_PTAG_CT_ARMOUR_TRAILER:
        break;

    case OPS_PTAG_CT_SIGNATURE_HEADER:
    case OPS_PTAG_CT_SIGNATURE_FOOTER:
        return callback_signature(content_, cbinfo);

        /*
    case OPS_PTAG_CT_UNARMOURED_TEXT:
        printf("OPS_PTAG_CT_UNARMOURED_TEXT\n");
        if(!skipping)
            {
            puts("Skipping...");
            skipping=ops_true;
            }
        fwrite(content->unarmoured_text.data,1,
               content->unarmoured_text.length,stdout);
        break;

    case OPS_PTAG_CT_PK_SESSION_KEY:
        return callback_pk_session_key(content_,cbinfo);

    case OPS_PARSER_CMD_GET_SECRET_KEY:
        return callback_cmd_get_secret_key(content_,cbinfo);

    case OPS_PARSER_CMD_GET_SK_PASSPHRASE:
        return callback_cmd_get_secret_key_passphrase(content_,cbinfo);

    case OPS_PTAG_CT_LITERAL_DATA_BODY:
        return callback_literal_data(content_,cbinfo);
        //      text=ops_mallocz(content->literal_data_body.length+1);
        //      memcpy(text,content->literal_data_body.data,content->literal_data_body.length);
        //              break;

    case OPS_PARSER_PTAG:
    case OPS_PTAG_CT_ARMOUR_HEADER:
    case OPS_PTAG_CT_ARMOUR_TRAILER:
    case OPS_PTAG_CT_ENCRYPTED_PK_SESSION_KEY:
    case OPS_PTAG_CT_COMPRESSED:
    case OPS_PTAG_CT_SE_IP_DATA_BODY:
    case OPS_PTAG_CT_SE_IP_DATA_HEADER:
        // Ignore these packets 
        // They're handled in ops_parse_one_packet()
        // and nothing else needs to be done
        break;
*/

    default:
        return callback_general(content_,cbinfo);
        }

    return OPS_RELEASE_MEMORY;
    }

// EOF