Hi,
Where is the problem in pthreads ?
I dont't know the BN_mod_exp_mon procedure bat we can try a simple
pthreads program, if I can help you I am happy.
Tomorrow i try openssl pthreads.
I have only a question.
You hare sure the problem is in pthreads end not in your common memory
access syncronization ?
2009/6/23 pcslara <pcsl...@yahoo.com.br>:
>
> Please
> Could someone have a simple example with pthread
> to show me!
> This program was compiled and run on an openSUSE 11.0 x86_64
> kernel 2.6.25.18. The program exits with 'Segmentation fault'.
>
>
> pcslara wrote:
>>
>> Hi friends,
>> This is my fisrt message here!
>> I'm making a parallel version of BN_mod_exp_mont.
>> However I am encountering many problems when using
>> pthreads.
>>
>> #include <openssl/crypto.h>
>> #include <openssl/rsa.h>
>> #include <openssl/bn.h>
>> #include <openssl/ossl_typ.h>
>> #include <openssl/objects.h>
>> #include <openssl/err.h>
>>
>> /* To use as callback in 'pthread_create()' */
>> void BN_mod_exp_mont_call( void * args[6] );
>> /* BN_mod_exp_mont Parallel version */
>> int BN_mod_exp_mont_t2(BIGNUM *r, const BIGNUM *a, const BIGNUM *e,
>> const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
>> int BN_split( const BIGNUM * e, BIGNUM * e1, BIGNUM * e2 );
>>
>> /* Lock Features */
>> void CRYPTO_thread_setup(void);
>> void CRYPTO_thread_cleanup(void);
>>
>> static unsigned long pthreads_thread_id(void );
>> static pthread_mutex_t *lock_cs;
>> static long *lock_count;
>> static void pthreads_locking_callback(int mode,int type,char *file,int
>> line);
>>
>> void CRYPTO_thread_setup(void) {
>> int i;
>> lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t));
>> lock_count=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long));
>> for (i=0; i<CRYPTO_num_locks(); i++) {
>> lock_count[i]=0;
>> pthread_mutex_init(&(lock_cs[i]),NULL);
>> }
>>
>> CRYPTO_set_id_callback((unsigned long (*)())pthreads_thread_id);
>> CRYPTO_set_locking_callback((void (*)())pthreads_locking_callback);
>> }
>> void CRYPTO_thread_cleanup(void) {
>> int i;
>> CRYPTO_set_locking_callback(NULL);
>> for (i=0; i<CRYPTO_num_locks(); i++)
>> {
>> pthread_mutex_destroy(&(lock_cs[i]));
>> }
>> OPENSSL_free(lock_cs);
>> OPENSSL_free(lock_count);
>> }
>> void pthreads_locking_callback(int mode, int type, char *file, int line) {
>> if (mode & CRYPTO_LOCK) {
>> pthread_mutex_lock(&(lock_cs[type]));
>> lock_count[type]++;
>> } else
>> pthread_mutex_unlock(&(lock_cs[type]));
>> }
>> unsigned long pthreads_thread_id(void) {
>> unsigned long ret;
>> ret=(unsigned long)pthread_self();
>> return(ret);
>> }
>> int BN_split( const BIGNUM * e, BIGNUM * e1, BIGNUM * e2 ) {
>> int r = (BN_num_bits( e ) + 1) / 2;
>> BN_copy( e1, e );
>> BN_mask_bits( e1, r );
>> BN_rshift( e2, e, r );
>> return r;
>> }
>> int BN_mod_exp_mont_t2(BIGNUM *r, const BIGNUM *a, const BIGNUM *e,
>> const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx) {
>> BIGNUM * e1, * e2, * a1, * a2;
>> BIGNUM * tmp;
>> int t = 0;
>>
>> BN_CTX_start( ctx );
>> e1 = BN_CTX_get( ctx );
>> e2 = BN_CTX_get( ctx );
>> a1 = BN_CTX_get( ctx );
>> a2 = BN_CTX_get( ctx );
>> tmp = BN_CTX_get( ctx );
>>
>> t = BN_split( e, e1, e2 );
>> BN_lshift( tmp, BN_value_one(), t );
>>
>> void * args[6];
>> pthread_t th;
>> args[0] = (void *) a1;
>> args[1] = (void *) a;
>> args[2] = (void *) e1;
>> args[3] = (void *) m;
>> args[4] = (void *) ctx;
>> args[5] = (void *) m_ctx;
>> pthread_create( &th, NULL, (void *)BN_mod_exp_mont_call, (void *) args
>> );
>> //BN_mod_exp_mont_call( args );
>> BN_mod_exp_mont( a2, a, tmp, m, ctx, m_ctx );
>> BN_mod_exp_mont( a2, a2, e2, m, ctx, m_ctx );
>> pthread_join( th, NULL );
>> BN_mod_mul( r, a1, a2, m, ctx );
>> BN_CTX_end( ctx );
>> }
>> void BN_mod_exp_mont_call( void * args[6] ) {
>> BN_mod_exp_mont( (BIGNUM *) args[0], (BIGNUM *)args[1], (BIGNUM
>> *)args[2],
>> (BIGNUM *)args[3], (BN_CTX *) args[4], (BN_MONT_CTX
>> *)args[5] );
>> }
>> int TestEncrypt() {
>> RSA * key;
>>
>> unsigned char ctext[256];
>> unsigned char ptext[256];
>> static unsigned char ptext_ex[] = "\x25\x44\x65\x66";
>>
>> key = RSA_generate_key( 512, RSA_F4, NULL, NULL );
>> key->meth->bn_mod_exp = BN_mod_exp_mont_t2;
>>
>> int clen = RSA_private_encrypt( sizeof( ptext_ex ) - 1, ptext_ex,
>> ctext, key, RSA_PKCS1_PADDING );
>>
>> if( clen == -1 ) { fprintf( stderr, "Bad encrypt\n"); return -1; }
>>
>> int plen = RSA_public_decrypt( clen, ctext, ptext, key,
>> RSA_PKCS1_PADDING );
>>
>> if( plen == -1 ) { fprintf( stderr, "Bad decrypt\n"); return -1; }
>>
>> if( memcmp( ptext, ptext_ex, plen ) != 0 ) {
>> fprintf( stderr,"Diffs ptext's\n");
>> return -1;
>> } else
>> return 0;
>> }
>> int main( int argc, char ** argv ) {
>> CRYPTO_thread_setup();
>> if( TestEncrypt() == 0 ){ fprintf( stdout, "Encrypt Ok!\n"); }
>> CRYPTO_thread_cleanup();
>> return 0;
>> }
>>
>> Obs:
>> For the test, I do
>>
>> key-> meth-> bn_mod_exp = BN_mod_exp_mont_t2;
>>
>> Thus the attribute 'meth' of RSA struct can not be const.
>>
>
> --
> View this message in context:
> http://www.nabble.com/Problem-with-pthread-and-OpenSSL-tp24073660p24165584.html
> Sent from the OpenSSL - User mailing list archive at Nabble.com.
> ______________________________________________________________________
> OpenSSL Project http://www.openssl.org
> User Support Mailing List openssl-us...@openssl.org
> Automated List Manager majord...@openssl.org
>
______________________________________________________________________
OpenSSL Project http://www.openssl.org
User Support Mailing List openssl-users@openssl.org
Automated List Manager majord...@openssl.org
