view release on metacpan or  search on metacpan

SMimeEngine.xs  view on Meta::CPAN

//
//        init_status = 0;
        return 0;
    }else{
        SSL_library_init();
        OpenSSL_add_all_algorithms();
        ERR_load_crypto_strings();
    }

    // ca path existence check
    if( (dd = opendir(cert_dir)) == NULL ){
        sprintf(errstring, "Error to access to CA path: %s", cert_dir);
        destroy_ui_method();
        return 1;
    }
    closedir(dd);
    ca_dir = cert_dir;

    if (!(store = create_store())){
        destroy_ui_method();
        sprintf(errstring, "Error setting up X509_STORE object");
        return 1;
    }

    // load signer certificate
    (signer) = load_cert(cert_file);
    if(!(signer)) {
        destroy_ui_method();
        sprintf(errstring, "Error to load certificate file: %s", cert_file);
        return 1;
    }

    // load certs to add to SMIME schema during the sign process
    if(other_cert_num && other_cert_num <= MAX_CERTS){
        int i;
        other4sign = sk_X509_new_null();

        for(i=0; i<other_cert_num; i++){
            X509 *tmp;
            FILE *fp;
            if (!(fp = fopen(other_cert[i], "r")) || !(tmp = PEM_read_X509(fp, NULL, NULL, NULL))){
                destroy_ui_method();
                sprintf(errstring, "Error reading chain certificate");
                return 1;
            }
            sk_X509_push(other4sign, tmp);
            fclose(fp);
        }
    }

    sign = &sign_old;
    if( engine_name && strcmp(engine_name,"openssl") != 0 ) {
       // LOAD ENGINE HW
        eng = load_engine(engine_name, libeng_file);
        if(!(eng)) {
            destroy_ui_method();
            sprintf(errstring, "Error to load engine: %s (%s)", engine_name, libeng_file);
            return 1;
        }

        if( !(pkey = ENGINE_load_private_key(eng, key_file, ui_method, NULL)) ){
            destroy_ui_method();
            ENGINE_cleanup();
            sprintf(errstring, "Error to load private key file: %s", key_file);
            return 1;
        }
     } else {
        FILE *fp;
        if (!(fp = fopen(key_file, "r")) ||
            !(pkey = PEM_read_PrivateKey(fp, NULL, NULL, NULL))){

            destroy_ui_method();
            sprintf(errstring, "Error to access to key file: %s", key_file);
            return 1;
        }
       close((int)(uintptr_t)fp);
     }

    init_status = 1;
    return 0;
}



/*
 * sign: sign the file "fname"
 *
 *  FIRMA
 *  /usr/local/bin/openssl smime -sign -signer /home/flazan/SMIME/CERTS/cert.pem -certfile /home/flazan/SMIME/CERTS/CnipaCA2.crt -inkey /home/flazan/SMIME/CERTS/key.pem -in /home/flazan/SMIME/MAIL/mail.txt -out /home/flazan/SMIME/MAIL/mail.txt.signed
 *
 * 1. path mail to sign (input)
 * 2. path mail signed (output)
 *
 * return 0 se ok, 1 altrimenti e imposta la var errstring
 */
int
sign_old(char *fname, char *outfname){
    BIO *biom, *out;
    PKCS7 *r;
    //STACK_OF(X509) *other = NULL;
    strcpy(errstring,"");

    if(!init_status){
        sprintf(errstring, "init must be run correctly");
        return 1;
    }


    biom = BIO_new_file(fname, "r");
    if(!biom) {
        sprintf(errstring, "Error to access to file: %s", fname);
        return 1;
    }

    //r = PKCS7_sign(signer, pkey, other, biom, PKCS7_DETACHED);
    r = PKCS7_sign(signer, pkey, other4sign, biom, PKCS7_DETACHED);
    if(!r) {
        ERR_print_errors_fp(stdout);
        sprintf(errstring, "Error to sign file %s", fname);
        BIO_free(biom);
        return 1;

SMimeEngine.xs  view on Meta::CPAN

        free(x->subject);
        free(x->serial);
        free(x->startdate);
        free(x->enddate);
        free(x->v3_email);
}

void
free_init(){
    X509_free(signer);
    sk_X509_pop_free(other4sign, X509_free);
    X509_STORE_free(store);
    EVP_PKEY_free(pkey);
    destroy_ui_method();
}

int
save_certs(char *signerfile, STACK_OF(X509) *signers){
        int i;
        BIO *tmp;
        if(!signerfile) return 1;
        tmp = BIO_new_file(signerfile, "w");
        if(!tmp) return 0;
        for(i = 0; i < sk_X509_num(signers); i++)
                PEM_write_bio_X509(tmp, sk_X509_value(signers, i));
        BIO_free(tmp);
        return 1;
}

/*
 * Restiruisce gli estremi di openssl
 *
 * Parametri
 * 0 - versione (es. OpenSSL 0.9.7i 14 Oct 2005)
 * 2 - prametri di compilazione (es. compiler: gcc -DOPENSSL_THREADS ...)
 * 3 - data compilazione (es. built on: Mon Dec  3 16:44:16 CET 2007)
 * 4 - piattaforma (es. platform: debug-linux-pentium)
 * 5 - path di installazione (es. OPENSSLDIR: \"/usr/local/openssl\")
 *
 */
int
ossl_param(int param, char **strOut){
    *strOut = (char *) SSLeay_version(param);
    return 1;
}

int
load_privk(char *prk, char *ncert){
    strcpy(errstring,"");

    if(pkey){
        EVP_PKEY_free(pkey);
    }
    if(signer){
        X509_free(signer);
    }

    // load key
    if( eng ){
        // ENGINE HW
        if( !(pkey = ENGINE_load_private_key(eng, prk, ui_method, NULL)) ){
            destroy_ui_method();
            ENGINE_cleanup();
            sprintf(errstring, "Error to load private key file: %s", prk);
            return 1;
        }
    }else{
        // ENGINE SW
        FILE *fp;
        if (!(fp = fopen(prk, "r")) ||
            !(pkey = PEM_read_PrivateKey(fp, NULL, NULL, NULL))){

            destroy_ui_method();
            sprintf(errstring, "Error to access to key file: %s", prk);
            return 1;
        }
        close((int)(uintptr_t)fp);
    }

    //load cert
    // load signer certificate
    (signer) = load_cert(ncert);
    if(!(signer)) {
        destroy_ui_method();
        sprintf(errstring, "Error to load certificate file: %s", ncert);
        return 1;
    }

    return 0;

}

/*
 * Return a selected type digest of input file
 *
 * 1 - input file path
 * 2 - hash type
 * 3 - calculated hash
 *
 * o se ok, 1 altrimenti e popola errstr
 */

int
digest(char *fname, char *dname, char **digestOut){

    const EVP_MD *dtype;
    EVP_MD_CTX *mdctx;
    int i, data_count;
    unsigned int dtype_len;
    FILE *fp;
    char *data;
    unsigned char digest_str[EVP_MAX_MD_SIZE];
    char* digestStart;
    strcpy(errstring,"");

    // initialize hash context and retrieve digest type by name
    OpenSSL_add_all_digests();
    if(!(dtype = EVP_get_digestbyname(dname))) {
        sprintf(errstring, "Unknown message digest: %s", dname);
        return 1;
    }