source: branches/backfire/package/openssl/patches/200-ocf-20100325.patch @ 29478

Last change on this file since 29478 was 29478, checked in by jow, 4 years ago

[backfire] openssl: update to v0.9.8r (CVE-2010-4180)

File size: 32.7 KB
  • Configure

    a b my $usage="Usage: Configure [no-<cipher> 
    3636#               (Default: KRB5_DIR/include) 
    3737# --with-krb5-flavor  Declare what flavor of Kerberos 5 is used.  Currently 
    3838#               supported values are "MIT" and "Heimdal".  A value is required. 
     39# --with-cryptodev Force support for cryptodev (ie., ocf-linux) 
     40# --with-cryptodev-digests Force support for cryptodev digests (generally slow) 
    3941# 
    4042# --test-sanity Make a number of sanity checks on the data in this file. 
    4143#               This is a debugging tool for OpenSSL developers. 
    my %table=( 
    557559##### Compaq Non-Stop Kernel (Tandem) 
    558560"tandem-c89","c89:-Ww -D__TANDEM -D_XOPEN_SOURCE -D_XOPEN_SOURCE_EXTENDED=1 -D_TANDEM_SOURCE -DB_ENDIAN::(unknown):::THIRTY_TWO_BIT:::", 
    559561 
     562# uClinux 
     563"uClinux-dist","$ENV{'CC'}:\$(CFLAGS)::-D_REENTRANT::\$(LDFLAGS) \$(LDLIBS):BN_LLONG::::::::::::\$(LIBSSL_dlfcn):linux-shared:-fPIC:-shared:.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR):$ENV{'RANLIB'}", 
     564"uClinux-dist64","$ENV{'CC'}:\$(CFLAGS)::-D_REENTRANT::\$(LDFLAGS) \$(LDLIBS):SIXTY_FOUR_BIT_LONG::::::::::::\$(LIBSSL_dlfcn):linux-shared:-fPIC:-shared:.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR):$ENV{'RANLIB'}", 
     565 
    560566); 
    561567 
    562568my @MK1MF_Builds=qw(VC-WIN64I VC-WIN64A 
    my $montasm=1; # but "no-montasm" is d 
    613619my $no_asm=0; 
    614620my $no_dso=0; 
    615621my $no_gmp=0; 
     622my $have_cryptodev=0; 
     623my $use_cryptodev_digests=0; 
    616624my @skip=(); 
    617625my $Makefile="Makefile"; 
    618626my $des_locl="crypto/des/des_locl.h"; 
    PROCESS_ARGS: 
    761769                        { 
    762770                        exit(&test_sanity()); 
    763771                        } 
     772                elsif (/^--with-cryptodev$/) 
     773                        { 
     774                                $have_cryptodev = 1; 
     775                        } 
     776                elsif (/^--with-cryptodev-digests$/) 
     777                        { 
     778                                $use_cryptodev_digests = 1; 
     779                        } 
    764780                elsif (/^--strict-warnings/) 
    765781                        { 
    766782                        $strict_warnings = 1; 
    foreach (sort (keys %disabled)) 
    10581074                        print " OPENSSL_NO_$ALGO"; 
    10591075                 
    10601076                        if (/^err$/)    { $flags .= "-DOPENSSL_NO_ERR "; } 
     1077                        elsif (/^hw$/)  { $flags .= "-DOPENSSL_NO_HW "; } 
    10611078                        elsif (/^asm$/) { $no_asm = 1; } 
    10621079                        } 
    10631080                else 
    if (!$no_krb5) 
    11871204                   $withargs{"krb5-dir"} ne ""; 
    11881205        } 
    11891206 
     1207# enable the linux cryptodev (ocf-linux) support 
     1208if ($have_cryptodev) 
     1209        { 
     1210        if ($use_cryptodev_digests) 
     1211                { 
     1212                $cflags = "-DUSE_CRYPTODEV_DIGESTS $cflags"; 
     1213                } 
     1214        $cflags = "-DHAVE_CRYPTODEV $cflags"; 
     1215        } 
     1216 
    11901217# The DSO code currently always implements all functions so that no 
    11911218# applications will have to worry about that from a compilation point 
    11921219# of view. However, the "method"s may return zero unless that platform 
  • INSTALL

    a b  
    103103                define preprocessor symbols, specify additional libraries, 
    104104                library directories or other compiler options. 
    105105 
     106  --with-cryptodev Enabled the BSD cryptodev engine even if we are not using 
     107                BSD.  Useful if you are running ocf-linux or something 
     108                similar.  Once enabled you can also enable the use of 
     109                cryptodev digests,  with is usually slower unless you have 
     110                large amounts data.  Use --with-cryptodev-digests to force 
     111                it. 
    106112 
    107113 Installation in Detail 
    108114 ---------------------- 
  • Makefile.org

    a b files: 
    499499 
    500500links: 
    501501        @$(PERL) $(TOP)/util/mkdir-p.pl include/openssl 
    502         @$(PERL) $(TOP)/util/mklink.pl include/openssl $(EXHEADER) 
     502        @$(PERL) $(TOP)/util/mklink.pl include/openssl $(HEADER) $(EXHEADER) 
    503503        @set -e; target=links; $(RECURSIVE_BUILD_CMD) 
    504504        @if [ -z "$(FIPSCANLIB)" ]; then \ 
    505505                set -e; target=links; dir=fips ; $(BUILD_CMD) ; \ 
  • Makefile.shared

    a b  
    66# properly 
    77 
    88# CC contains the current compiler.  This one MUST be defined 
    9 CC=cc 
    10 CFLAGS=$(CFLAG) 
     9CC?=cc 
     10CFLAGS?=$(CFLAG) 
    1111# LDFLAGS contains flags to be used when temporary object files (when building 
    1212# shared libraries) are created, or when an application is linked. 
    1313# SHARED_LDFLAGS contains flags to be used when the shared library is created. 
    14 LDFLAGS= 
    15 SHARED_LDFLAGS= 
     14LDFLAGS?= 
     15SHARED_LDFLAGS?= 
    1616 
    1717# LIBNAME contains just the name of the library, without prefix ("lib" 
    1818# on Unix, "cyg" for certain forms under Cygwin...) or suffix (.a, .so, 
  • config

    a b case "${SYSTEM}:${RELEASE}:${VERSION}:${ 
    270270                echo "ppc-apple-darwin${VERSION}" 
    271271                ;; 
    272272            *) 
    273                 echo "i386-apple-darwin${VERSION}" 
     273                echo "${MACHINE}-apple-darwin${VERSION}" 
    274274                ;; 
    275275        esac 
    276276        exit 0 
    exit 0 
    399399# this is where the translation occurs into SSLeay terms 
    400400# --------------------------------------------------------------------------- 
    401401 
    402 GCCVER=`(gcc -dumpversion) 2>/dev/null` 
     402GCCVER=`(${CC:-gcc} -dumpversion) 2>/dev/null` 
    403403if [ "$GCCVER" != "" ]; then 
    404404  # then strip off whatever prefix egcs prepends the number with... 
    405405  # Hopefully, this will work for any future prefixes as well. 
    echo Operating system: $GUESSOS 
    488488# script above so we end up with values in vars but that would take 
    489489# more time that I want to waste at the moment 
    490490case "$GUESSOS" in 
     491  uClinux*64*) 
     492    OUT=uClinux-dist64 
     493        ;; 
     494  uClinux*) 
     495    OUT=uClinux-dist 
     496        ;; 
    491497  mips2-sgi-irix) 
    492498        CPU=`(hinv -t cpu) 2>/dev/null | head -1 | sed 's/^CPU:[^R]*R\([0-9]*\).*/\1/'` 
    493499        CPU=${CPU:-0} 
  • apps/apps.h

    a b  
    112112#ifndef HEADER_APPS_H 
    113113#define HEADER_APPS_H 
    114114 
    115 #include "e_os.h" 
     115#include <openssl/e_os.h> 
    116116 
    117117#include <openssl/bio.h> 
    118118#include <openssl/x509.h> 
  • apps/progs.h

    a b FUNCTION functions[] = { 
    129129#ifndef OPENSSL_NO_ENGINE 
    130130        {FUNC_TYPE_GENERAL,"engine",engine_main}, 
    131131#endif 
     132#ifndef OPENSSL_NO_OCSP 
    132133        {FUNC_TYPE_GENERAL,"ocsp",ocsp_main}, 
     134#endif 
    133135        {FUNC_TYPE_GENERAL,"prime",prime_main}, 
    134136#ifndef OPENSSL_NO_MD2 
    135137        {FUNC_TYPE_MD,"md2",dgst_main}, 
  • apps/speed.c

    a b static const char *names[ALGOR_NUM]={ 
    302302  "evp","sha256","sha512", 
    303303  "aes-128 ige","aes-192 ige","aes-256 ige"}; 
    304304static double results[ALGOR_NUM][SIZE_NUM]; 
    305 static int lengths[SIZE_NUM]={16,64,256,1024,8*1024}; 
     305static int lengths[SIZE_NUM]={16,64,256,1024,2*1024,4*1024}; 
    306306#ifndef OPENSSL_NO_RSA 
    307307static double rsa_results[RSA_NUM][2]; 
    308308#endif 
    static SIGRETTYPE sig_done(int sig) 
    342342#define START   0 
    343343#define STOP    1 
    344344 
     345static int do_cpu = 0; 
     346 
     347#ifdef __linux__ 
     348 
     349#define HAVE_CPU_USAGE  1 
     350 
     351/* 
     352 * record CPU usage as well 
     353 */ 
     354 
     355struct cpu_stat { 
     356        unsigned int    user; 
     357        unsigned int    nice; 
     358        unsigned int    system; 
     359        unsigned int    idle; 
     360        unsigned int    total; 
     361}; 
     362 
     363static unsigned int cpu_usage[ALGOR_NUM][SIZE_NUM]; 
     364static unsigned int rsa_cpu_usage[RSA_NUM][2]; 
     365static unsigned int dsa_cpu_usage[DSA_NUM][2]; 
     366static struct cpu_stat cpu_start, cpu_finish; 
     367 
     368static void 
     369get_cpu(int s) 
     370{ 
     371        FILE *fp = NULL; 
     372        unsigned char   buf[80]; 
     373        struct cpu_stat *st = s == START ? &cpu_start : &cpu_finish; 
     374 
     375        memset(st, 0, sizeof(*st)); 
     376 
     377        if (fp == NULL) 
     378                fp = fopen("/proc/stat", "r"); 
     379        if (!fp) 
     380                return; 
     381        if (fseek(fp, 0, SEEK_SET) == -1) { 
     382                fclose(fp); 
     383                return; 
     384        } 
     385        fscanf(fp, "%s %d %d %d %d", &buf[0], &st->user, &st->nice, 
     386                &st->system, &st->idle); 
     387        st->total = st->user + st->nice + st->system + st->idle; 
     388        fclose(fp); 
     389} 
     390 
     391static unsigned int 
     392calc_cpu() 
     393{ 
     394        unsigned int total, res; 
     395 
     396        total  = cpu_finish.total - cpu_start.total; 
     397        if (total <= 0) 
     398                return 0; 
     399#if 1 // busy 
     400        res   = ((cpu_finish.system + cpu_finish.user + cpu_finish.nice) - 
     401                         (cpu_start.system + cpu_start.user + cpu_start.nice)) * 
     402                         100 / total; 
     403#endif 
     404#if 0 // system 
     405        res   = (cpu_finish.system - cpu_start.system) * 100 / total; 
     406#endif 
     407#if 0 // user 
     408        res   = (cpu_finish.user   - cpu_start.user)   * 100 / total; 
     409#endif 
     410#if 0 // nice 
     411        res   = (cpu_finish.nice   - cpu_start.nice)   * 100 / total; 
     412#endif 
     413#if 0 // idle 
     414        res   = (cpu_finish.idle   - cpu_start.idle)   * 100 / total; 
     415#endif 
     416        return(res); 
     417} 
     418 
     419#endif 
     420 
    345421#if defined(OPENSSL_SYS_NETWARE) 
    346422 
    347423   /* for NetWare the best we can do is use clock() which returns the 
    static double Time_F(int s) 
    372448        { 
    373449        double ret; 
    374450 
     451        if (do_cpu) 
     452                get_cpu(s); 
     453 
    375454#ifdef USE_TOD 
    376455        if(usertime) 
    377456                { 
    int MAIN(int argc, char **argv) 
    839918                        j--;    /* Otherwise, -elapsed gets confused with 
    840919                                   an algorithm. */ 
    841920                        } 
     921#ifdef HAVE_CPU_USAGE 
     922                else if ((argc > 0) && (strcmp(*argv,"-cpu") == 0)) 
     923                        { 
     924                        do_cpu = 1; 
     925                        j--;    /* Otherwise, -cpu gets confused with 
     926                                   an algorithm. */ 
     927                        } 
     928#endif 
    842929                else if ((argc > 0) && (strcmp(*argv,"-evp") == 0)) 
    843930                        { 
    844931                        argc--; 
    int MAIN(int argc, char **argv) 
    12671354#ifndef NO_FORK 
    12681355                        BIO_printf(bio_err,"-multi n        run n benchmarks in parallel.\n"); 
    12691356#endif 
     1357#ifdef HAVE_CPU_USAGE 
     1358                        BIO_printf(bio_err,"-cpu            calculate cpu utilisation.\n"); 
     1359#endif 
    12701360                        goto end; 
    12711361                        } 
    12721362                argc--; 
    int MAIN(int argc, char **argv) 
    12741364                j++; 
    12751365                } 
    12761366 
    1277 #ifndef NO_FORK 
    1278         if(multi && do_multi(multi)) 
    1279                 goto show_res; 
    1280 #endif 
    1281  
    12821367        if (j == 0) 
    12831368                { 
    12841369                for (i=0; i<ALGOR_NUM; i++) 
    int MAIN(int argc, char **argv) 
    16121697        signal(SIGALRM,sig_done); 
    16131698#endif /* SIGALRM */ 
    16141699 
     1700#ifndef NO_FORK /* Do this a late as possible to give better CPU readings */ 
     1701        if(multi && do_multi(multi)) 
     1702                goto show_res; 
     1703#endif 
     1704 
    16151705#ifndef OPENSSL_NO_MD2 
    16161706        if (doit[D_MD2]) 
    16171707                { 
    int MAIN(int argc, char **argv) 
    20412131                                /* -O3 -fschedule-insns messes up an 
    20422132                                 * optimization here!  names[D_EVP] 
    20432133                                 * somehow becomes NULL */ 
    2044                                 print_message(names[D_EVP],save_count, 
    2045                                         lengths[j]); 
    20462134 
    20472135                                EVP_CIPHER_CTX_init(&ctx); 
    20482136                                if(decrypt) 
    int MAIN(int argc, char **argv) 
    20512139                                        EVP_EncryptInit_ex(&ctx,evp_cipher,NULL,key16,iv); 
    20522140                                EVP_CIPHER_CTX_set_padding(&ctx, 0); 
    20532141 
     2142                                print_message(names[D_EVP],save_count, 
     2143                                        lengths[j]); 
     2144 
    20542145                                Time_F(START); 
    20552146                                if(decrypt) 
    20562147                                        for (count=0,run=1; COND(save_count*4*lengths[0]/lengths[j]); count++) 
    int MAIN(int argc, char **argv) 
    21152206                                        } 
    21162207                                } 
    21172208                        d=Time_F(STOP); 
     2209                        if (do_cpu) 
     2210                                rsa_cpu_usage[j][0] = calc_cpu(); 
    21182211                        BIO_printf(bio_err,mr ? "+R1:%ld:%d:%.2f\n" 
    21192212                                   : "%ld %d bit private RSA's in %.2fs\n", 
    21202213                                   count,rsa_bits[j],d); 
    int MAIN(int argc, char **argv) 
    21502243                                        } 
    21512244                                } 
    21522245                        d=Time_F(STOP); 
     2246                        if (do_cpu) 
     2247                                rsa_cpu_usage[j][1] = calc_cpu(); 
    21532248                        BIO_printf(bio_err,mr ? "+R2:%ld:%d:%.2f\n" 
    21542249                                   : "%ld %d bit public RSA's in %.2fs\n", 
    21552250                                   count,rsa_bits[j],d); 
    int MAIN(int argc, char **argv) 
    22092304                                        } 
    22102305                                } 
    22112306                        d=Time_F(STOP); 
     2307                        if (do_cpu) 
     2308                                dsa_cpu_usage[j][0] = calc_cpu(); 
    22122309                        BIO_printf(bio_err,mr ? "+R3:%ld:%d:%.2f\n" 
    22132310                                   : "%ld %d bit DSA signs in %.2fs\n", 
    22142311                                   count,dsa_bits[j],d); 
    int MAIN(int argc, char **argv) 
    22442341                                        } 
    22452342                                } 
    22462343                        d=Time_F(STOP); 
     2344                        if (do_cpu) 
     2345                                dsa_cpu_usage[j][1] = calc_cpu(); 
    22472346                        BIO_printf(bio_err,mr ? "+R4:%ld:%d:%.2f\n" 
    22482347                                   : "%ld %d bit DSA verify in %.2fs\n", 
    22492348                                   count,dsa_bits[j],d); 
    show_res: 
    25382637                        fprintf(stdout,"The 'numbers' are in 1000s of bytes per second processed.\n");  
    25392638                        fprintf(stdout,"type        "); 
    25402639                        } 
    2541                 for (j=0;  j<SIZE_NUM; j++) 
     2640                for (j=0;  j<SIZE_NUM; j++) { 
    25422641                        fprintf(stdout,mr ? ":%d" : "%7d bytes",lengths[j]); 
     2642                        if (do_cpu && !mr) 
     2643                                fprintf(stdout, " /cpu"); 
     2644                } 
    25432645                fprintf(stdout,"\n"); 
    25442646                } 
    25452647 
    25462648        for (k=0; k<ALGOR_NUM; k++) 
    25472649                { 
    25482650                if (!doit[k]) continue; 
     2651                if (k == D_EVP) { 
     2652                        if (evp_cipher) 
     2653                                names[D_EVP]=OBJ_nid2ln(evp_cipher->nid); 
     2654                        else 
     2655                                names[D_EVP]=OBJ_nid2ln(evp_md->type); 
     2656                } 
    25492657                if(mr) 
    25502658                        fprintf(stdout,"+F:%d:%s",k,names[k]); 
    25512659                else 
    show_res: 
    25562664                                fprintf(stdout," %11.2fk",results[k][j]/1e3); 
    25572665                        else 
    25582666                                fprintf(stdout,mr ? ":%.2f" : " %11.2f ",results[k][j]); 
     2667                        if (do_cpu) 
     2668                                fprintf(stdout, mr ? "/%d" : "/%%%-3d", cpu_usage[k][j]); 
    25592669                        } 
    25602670                fprintf(stdout,"\n"); 
    25612671                } 
    show_res: 
    25702680                        j=0; 
    25712681                        } 
    25722682                if(mr) 
    2573                         fprintf(stdout,"+F2:%u:%u:%f:%f\n", 
    2574                                 k,rsa_bits[k],rsa_results[k][0], 
    2575                                 rsa_results[k][1]); 
    2576                 else 
    2577                         fprintf(stdout,"rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n", 
    2578                                 rsa_bits[k],rsa_results[k][0],rsa_results[k][1], 
    2579                                 1.0/rsa_results[k][0],1.0/rsa_results[k][1]); 
     2683                        fprintf(stdout,"+F2:%u:%u:%f", k,rsa_bits[k],rsa_results[k][0]); 
     2684                else 
     2685                        fprintf(stdout,"rsa %4u bits %8.6fs",rsa_bits[k],rsa_results[k][0]); 
     2686                if (do_cpu) 
     2687                        fprintf(stdout, mr ? "/%d": "/%%%-3d", rsa_cpu_usage[k][0]); 
     2688                fprintf(stdout, mr ? ":%f" : " %8.6fs", rsa_results[k][1]); 
     2689                if (do_cpu) 
     2690                        fprintf(stdout, mr ? "/%d": "/%%%-3d", rsa_cpu_usage[k][1]); 
     2691                if(!mr) 
     2692                        fprintf(stdout, " %8.1f %8.1f", 
     2693                                        1.0/rsa_results[k][0],1.0/rsa_results[k][1]); 
     2694                fprintf(stdout, "\n"); 
    25802695                } 
    25812696#endif 
    25822697#ifndef OPENSSL_NO_DSA 
    show_res: 
    25902705                        j=0; 
    25912706                        } 
    25922707                if(mr) 
    2593                         fprintf(stdout,"+F3:%u:%u:%f:%f\n", 
    2594                                 k,dsa_bits[k],dsa_results[k][0],dsa_results[k][1]); 
     2708                        fprintf(stdout,"+F3:%u:%u:%f", k,dsa_bits[k],dsa_results[k][0]); 
    25952709                else 
    2596                         fprintf(stdout,"dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n", 
    2597                                 dsa_bits[k],dsa_results[k][0],dsa_results[k][1], 
    2598                                 1.0/dsa_results[k][0],1.0/dsa_results[k][1]); 
     2710                        fprintf(stdout,"dsa %4u bits %8.6fs",dsa_bits[k],dsa_results[k][0]); 
     2711                if (do_cpu) 
     2712                        fprintf(stdout, mr ? "/%d": "/%%%-3d", dsa_cpu_usage[k][0]); 
     2713                fprintf(stdout, mr ? ":%f" : " %8.6fs", dsa_results[k][1]); 
     2714                if (do_cpu) 
     2715                        fprintf(stdout, mr ? "/%d": "/%%%-3d", dsa_cpu_usage[k][1]); 
     2716                if(!mr) 
     2717                        fprintf(stdout, " %8.1f %8.1f", 
     2718                                        1.0/dsa_results[k][0],1.0/dsa_results[k][1]); 
     2719                fprintf(stdout, "\n"); 
    25992720                } 
    26002721#endif 
    26012722#ifndef OPENSSL_NO_ECDSA 
    static void pkey_print_message(const cha 
    27202841 
    27212842static void print_result(int alg,int run_no,int count,double time_used) 
    27222843        { 
    2723         BIO_printf(bio_err,mr ? "+R:%d:%s:%f\n" 
    2724                    : "%d %s's in %.2fs\n",count,names[alg],time_used); 
     2844        if (do_cpu) 
     2845            cpu_usage[alg][run_no] = calc_cpu(); 
     2846        BIO_printf(bio_err,mr ? "+R:%ld:%s:%f\n" 
     2847                   : "%ld %s's in %.2fs\n",count,names[alg],time_used); 
    27252848        results[alg][run_no]=((double)count)/time_used*lengths[run_no]; 
    27262849        } 
    27272850 
    static int do_multi(int multi) 
    28162939                                p=buf+3; 
    28172940                                alg=atoi(sstrsep(&p,sep)); 
    28182941                                sstrsep(&p,sep); 
    2819                                 for(j=0 ; j < SIZE_NUM ; ++j) 
     2942                                for(j=0 ; j < SIZE_NUM ; ++j) { 
     2943                                        if (do_cpu && strchr(p, '/')) 
     2944                                                cpu_usage[alg][j] = atoi(strchr(p, '/') + 1); 
    28202945                                        results[alg][j]+=atof(sstrsep(&p,sep)); 
    28212946                                } 
    2822                         else if(!strncmp(buf,"+F2:",4)) 
    2823                                 { 
    2824                                 int k; 
    2825                                 double d; 
    2826                                  
    2827                                 p=buf+4; 
    2828                                 k=atoi(sstrsep(&p,sep)); 
    2829                                 sstrsep(&p,sep); 
    2830  
    2831                                 d=atof(sstrsep(&p,sep)); 
    2832                                 if(n) 
    2833                                         rsa_results[k][0]=1/(1/rsa_results[k][0]+1/d); 
    2834                                 else 
    2835                                         rsa_results[k][0]=d; 
    2836  
    2837                                 d=atof(sstrsep(&p,sep)); 
    2838                                 if(n) 
    2839                                         rsa_results[k][1]=1/(1/rsa_results[k][1]+1/d); 
    2840                                 else 
    2841                                         rsa_results[k][1]=d; 
    28422947                                } 
    28432948                        else if(!strncmp(buf,"+F2:",4)) 
    28442949                                { 
    static int do_multi(int multi) 
    28492954                                k=atoi(sstrsep(&p,sep)); 
    28502955                                sstrsep(&p,sep); 
    28512956 
     2957                                /* before we move the token along */ 
     2958                                if (do_cpu && strchr(p, '/')) 
     2959                                        rsa_cpu_usage[k][0] = atoi(strchr(p, '/') + 1); 
    28522960                                d=atof(sstrsep(&p,sep)); 
    28532961                                if(n) 
    28542962                                        rsa_results[k][0]=1/(1/rsa_results[k][0]+1/d); 
    28552963                                else 
    28562964                                        rsa_results[k][0]=d; 
    28572965 
     2966                                /* before we move the token along */ 
     2967                                if (do_cpu && strchr(p, '/')) 
     2968                                        rsa_cpu_usage[k][1] = atoi(strchr(p, '/') + 1); 
    28582969                                d=atof(sstrsep(&p,sep)); 
    28592970                                if(n) 
    28602971                                        rsa_results[k][1]=1/(1/rsa_results[k][1]+1/d); 
    static int do_multi(int multi) 
    28702981                                k=atoi(sstrsep(&p,sep)); 
    28712982                                sstrsep(&p,sep); 
    28722983 
     2984                                /* before we move the token along */ 
     2985                                if (do_cpu && strchr(p, '/')) 
     2986                                        dsa_cpu_usage[k][0] = atoi(strchr(p, '/') + 1); 
    28732987                                d=atof(sstrsep(&p,sep)); 
    28742988                                if(n) 
    28752989                                        dsa_results[k][0]=1/(1/dsa_results[k][0]+1/d); 
    28762990                                else 
    28772991                                        dsa_results[k][0]=d; 
    28782992 
     2993                                /* before we move the token along */ 
     2994                                if (do_cpu && strchr(p, '/')) 
     2995                                        dsa_cpu_usage[k][1] = atoi(strchr(p, '/') + 1); 
    28792996                                d=atof(sstrsep(&p,sep)); 
    28802997                                if(n) 
    28812998                                        dsa_results[k][1]=1/(1/dsa_results[k][1]+1/d); 
  • crypto/cryptlib.h

    a b  
    6262#include <stdlib.h> 
    6363#include <string.h> 
    6464 
    65 #include "e_os.h" 
     65#include <openssl/e_os.h> 
    6666 
    6767#ifdef OPENSSL_USE_APPLINK 
    6868#define BIO_FLAGS_UPLINK 0x8000 
  • crypto/engine/eng_all.c

    a b void ENGINE_load_builtin_engines(void) 
    113113#endif 
    114114        } 
    115115 
    116 #if defined(__OpenBSD__) || defined(__FreeBSD__) 
     116#if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(HAVE_CRYPTODEV) 
    117117void ENGINE_setup_bsd_cryptodev(void) { 
    118118        static int bsd_cryptodev_default_loaded = 0; 
    119119        if (!bsd_cryptodev_default_loaded) { 
  • crypto/engine/eng_cryptodev.c

    a b ENGINE_load_cryptodev(void) 
    7272struct dev_crypto_state { 
    7373        struct session_op d_sess; 
    7474        int d_fd; 
     75 
     76#ifdef USE_CRYPTODEV_DIGESTS 
     77        char dummy_mac_key[20]; 
     78 
     79        unsigned char digest_res[20]; 
     80        char *mac_data; 
     81        int mac_len; 
     82 
     83        int copy; 
     84#endif 
    7585}; 
    7686 
    7787static u_int32_t cryptodev_asymfeat = 0; 
    static u_int32_t cryptodev_asymfeat = 0; 
    7989static int get_asym_dev_crypto(void); 
    8090static int open_dev_crypto(void); 
    8191static int get_dev_crypto(void); 
    82 static int cryptodev_max_iv(int cipher); 
    83 static int cryptodev_key_length_valid(int cipher, int len); 
    84 static int cipher_nid_to_cryptodev(int nid); 
    8592static int get_cryptodev_ciphers(const int **cnids); 
    8693/*static int get_cryptodev_digests(const int **cnids);*/ 
    8794static int cryptodev_usable_ciphers(const int **nids); 
    static struct { 
    134141        int     ivmax; 
    135142        int     keylen; 
    136143} ciphers[] = { 
     144        { CRYPTO_ARC4,                  NID_rc4,                0,      16, }, 
    137145        { CRYPTO_DES_CBC,               NID_des_cbc,            8,       8, }, 
    138146        { CRYPTO_3DES_CBC,              NID_des_ede3_cbc,       8,      24, }, 
    139147        { CRYPTO_AES_CBC,               NID_aes_128_cbc,        16,     16, }, 
     148        { CRYPTO_AES_CBC,               NID_aes_192_cbc,        16,     24, }, 
     149        { CRYPTO_AES_CBC,               NID_aes_256_cbc,        16,     32, }, 
    140150        { CRYPTO_BLF_CBC,               NID_bf_cbc,             8,      16, }, 
    141151        { CRYPTO_CAST_CBC,              NID_cast5_cbc,          8,      16, }, 
    142152        { CRYPTO_SKIPJACK_CBC,          NID_undef,              0,       0, }, 
    static struct { 
    147157static struct { 
    148158        int     id; 
    149159        int     nid; 
     160        int     keylen; 
    150161} digests[] = { 
    151         { CRYPTO_SHA1_HMAC,             NID_hmacWithSHA1,       }, 
    152         { CRYPTO_RIPEMD160_HMAC,        NID_ripemd160,          }, 
    153         { CRYPTO_MD5_KPDK,              NID_undef,              }, 
    154         { CRYPTO_SHA1_KPDK,             NID_undef,              }, 
    155         { CRYPTO_MD5,                   NID_md5,                }, 
    156         { CRYPTO_SHA1,                  NID_undef,              }, 
    157         { 0,                            NID_undef,              }, 
     162        { CRYPTO_MD5_HMAC,              NID_hmacWithMD5,        16}, 
     163        { CRYPTO_SHA1_HMAC,             NID_hmacWithSHA1,       20}, 
     164        { CRYPTO_RIPEMD160_HMAC,        NID_ripemd160,          16/*?*/}, 
     165        { CRYPTO_MD5_KPDK,              NID_undef,              0}, 
     166        { CRYPTO_SHA1_KPDK,             NID_undef,              0}, 
     167        { CRYPTO_MD5,                   NID_md5,                16}, 
     168        { CRYPTO_SHA1,                  NID_sha1,               20}, 
     169        { 0,                            NID_undef,              0}, 
    158170}; 
    159171#endif 
    160172 
    open_dev_crypto(void) 
    182194static int 
    183195get_dev_crypto(void) 
    184196{ 
    185         int fd, retfd; 
     197        static int fd = -1; 
     198        int retfd; 
    186199 
    187         if ((fd = open_dev_crypto()) == -1) 
    188                 return (-1); 
     200        if (fd == -1) { 
     201                if ((fd = open_dev_crypto()) == -1) 
     202                        return (-1); 
     203                if (fcntl(fd, F_SETFD, 1) == -1) { 
     204                        close(fd); 
     205                        return (-1); 
     206                } 
     207        } 
    189208        if (ioctl(fd, CRIOGET, &retfd) == -1) 
    190209                return (-1); 
    191210 
    get_asym_dev_crypto(void) 
    209228} 
    210229 
    211230/* 
    212  * XXXX this needs to be set for each alg - and determined from 
    213  * a running card. 
    214  */ 
    215 static int 
    216 cryptodev_max_iv(int cipher) 
    217 { 
    218         int i; 
    219  
    220         for (i = 0; ciphers[i].id; i++) 
    221                 if (ciphers[i].id == cipher) 
    222                         return (ciphers[i].ivmax); 
    223         return (0); 
    224 } 
    225  
    226 /* 
    227  * XXXX this needs to be set for each alg - and determined from 
    228  * a running card. For now, fake it out - but most of these 
    229  * for real devices should return 1 for the supported key 
    230  * sizes the device can handle. 
    231  */ 
    232 static int 
    233 cryptodev_key_length_valid(int cipher, int len) 
    234 { 
    235         int i; 
    236  
    237         for (i = 0; ciphers[i].id; i++) 
    238                 if (ciphers[i].id == cipher) 
    239                         return (ciphers[i].keylen == len); 
    240         return (0); 
    241 } 
    242  
    243 /* convert libcrypto nids to cryptodev */ 
    244 static int 
    245 cipher_nid_to_cryptodev(int nid) 
    246 { 
    247         int i; 
    248  
    249         for (i = 0; ciphers[i].id; i++) 
    250                 if (ciphers[i].nid == nid) 
    251                         return (ciphers[i].id); 
    252         return (0); 
    253 } 
    254  
    255 /* 
    256231 * Find out what ciphers /dev/crypto will let us have a session for. 
    257232 * XXX note, that some of these openssl doesn't deal with yet! 
    258233 * returning them here is harmless, as long as we return NULL 
    get_cryptodev_ciphers(const int **cnids) 
    270245                return (0); 
    271246        } 
    272247        memset(&sess, 0, sizeof(sess)); 
    273         sess.key = (caddr_t)"123456781234567812345678"; 
     248        sess.key = (caddr_t)"123456789abcdefghijklmno"; 
    274249 
    275250        for (i = 0; ciphers[i].id && count < CRYPTO_ALGORITHM_MAX; i++) { 
    276251                if (ciphers[i].nid == NID_undef) 
    get_cryptodev_digests(const int **cnids) 
    310285                return (0); 
    311286        } 
    312287        memset(&sess, 0, sizeof(sess)); 
     288        sess.mackey = (caddr_t)"123456789abcdefghijklmno"; 
    313289        for (i = 0; digests[i].id && count < CRYPTO_ALGORITHM_MAX; i++) { 
    314290                if (digests[i].nid == NID_undef) 
    315291                        continue; 
    316292                sess.mac = digests[i].id; 
     293                sess.mackeylen = digests[i].keylen; 
    317294                sess.cipher = 0; 
    318295                if (ioctl(fd, CIOCGSESSION, &sess) != -1 && 
    319296                    ioctl(fd, CIOCFSESSION, &sess.ses) != -1) 
    cryptodev_usable_ciphers(const int **nid 
    360337static int 
    361338cryptodev_usable_digests(const int **nids) 
    362339{ 
     340#ifdef USE_CRYPTODEV_DIGESTS 
     341        return (get_cryptodev_digests(nids)); 
     342#else 
    363343        /* 
    364344         * XXXX just disable all digests for now, because it sucks. 
    365345         * we need a better way to decide this - i.e. I may not 
    cryptodev_usable_digests(const int **nid 
    374354         */ 
    375355        *nids = NULL; 
    376356        return (0); 
     357#endif 
    377358} 
    378359 
    379360static int 
    cryptodev_init_key(EVP_CIPHER_CTX *ctx,  
    436417{ 
    437418        struct dev_crypto_state *state = ctx->cipher_data; 
    438419        struct session_op *sess = &state->d_sess; 
    439         int cipher; 
    440  
    441         if ((cipher = cipher_nid_to_cryptodev(ctx->cipher->nid)) == NID_undef) 
    442                 return (0); 
     420        int cipher, i; 
    443421 
    444         if (ctx->cipher->iv_len > cryptodev_max_iv(cipher)) 
    445                 return (0); 
     422        for (i = 0; ciphers[i].id; i++) 
     423                if (ctx->cipher->nid == ciphers[i].nid && 
     424                    ctx->cipher->iv_len <= ciphers[i].ivmax && 
     425                    ctx->key_len == ciphers[i].keylen) { 
     426                        cipher = ciphers[i].id; 
     427                        break; 
     428                } 
    446429 
    447         if (!cryptodev_key_length_valid(cipher, ctx->key_len)) 
     430        if (!ciphers[i].id) { 
     431                state->d_fd = -1; 
    448432                return (0); 
     433        } 
    449434 
    450435        memset(sess, 0, sizeof(struct session_op)); 
    451436 
    cryptodev_cleanup(EVP_CIPHER_CTX *ctx) 
    505490 * gets called when libcrypto requests a cipher NID. 
    506491 */ 
    507492 
     493/* RC4 */ 
     494const EVP_CIPHER cryptodev_rc4 = { 
     495        NID_rc4, 
     496        1, 16, 0, 
     497        EVP_CIPH_VARIABLE_LENGTH, 
     498        cryptodev_init_key, 
     499        cryptodev_cipher, 
     500        cryptodev_cleanup, 
     501        sizeof(struct dev_crypto_state), 
     502        NULL, 
     503        NULL, 
     504        NULL 
     505}; 
     506 
    508507/* DES CBC EVP */ 
    509508const EVP_CIPHER cryptodev_des_cbc = { 
    510509        NID_des_cbc, 
    const EVP_CIPHER cryptodev_aes_cbc = { 
    572571        NULL 
    573572}; 
    574573 
     574const EVP_CIPHER cryptodev_aes_192_cbc = { 
     575        NID_aes_192_cbc, 
     576        16, 24, 16, 
     577        EVP_CIPH_CBC_MODE, 
     578        cryptodev_init_key, 
     579        cryptodev_cipher, 
     580        cryptodev_cleanup, 
     581        sizeof(struct dev_crypto_state), 
     582        EVP_CIPHER_set_asn1_iv, 
     583        EVP_CIPHER_get_asn1_iv, 
     584        NULL 
     585}; 
     586 
     587const EVP_CIPHER cryptodev_aes_256_cbc = { 
     588        NID_aes_256_cbc, 
     589        16, 32, 16, 
     590        EVP_CIPH_CBC_MODE, 
     591        cryptodev_init_key, 
     592        cryptodev_cipher, 
     593        cryptodev_cleanup, 
     594        sizeof(struct dev_crypto_state), 
     595        EVP_CIPHER_set_asn1_iv, 
     596        EVP_CIPHER_get_asn1_iv, 
     597        NULL 
     598}; 
     599 
    575600/* 
    576601 * Registered by the ENGINE when used to find out how to deal with 
    577602 * a particular NID in the ENGINE. this says what we'll do at the 
    cryptodev_engine_ciphers(ENGINE *e, cons 
    585610                return (cryptodev_usable_ciphers(nids)); 
    586611 
    587612        switch (nid) { 
     613        case NID_rc4: 
     614                *cipher = &cryptodev_rc4; 
     615                break; 
    588616        case NID_des_ede3_cbc: 
    589617                *cipher = &cryptodev_3des_cbc; 
    590618                break; 
    cryptodev_engine_ciphers(ENGINE *e, cons 
    600628        case NID_aes_128_cbc: 
    601629                *cipher = &cryptodev_aes_cbc; 
    602630                break; 
     631        case NID_aes_192_cbc: 
     632                *cipher = &cryptodev_aes_192_cbc; 
     633                break; 
     634        case NID_aes_256_cbc: 
     635                *cipher = &cryptodev_aes_256_cbc; 
     636                break; 
    603637        default: 
    604638                *cipher = NULL; 
    605639                break; 
    cryptodev_engine_ciphers(ENGINE *e, cons 
    607641        return (*cipher != NULL); 
    608642} 
    609643 
     644 
     645#ifdef USE_CRYPTODEV_DIGESTS 
     646 
     647/* convert digest type to cryptodev */ 
     648static int 
     649digest_nid_to_cryptodev(int nid) 
     650{ 
     651        int i; 
     652 
     653        for (i = 0; digests[i].id; i++) 
     654                if (digests[i].nid == nid) 
     655                        return (digests[i].id); 
     656        return (0); 
     657} 
     658 
     659 
     660static int 
     661digest_key_length(int nid) 
     662{ 
     663        int i; 
     664 
     665        for (i = 0; digests[i].id; i++) 
     666                if (digests[i].nid == nid) 
     667                        return digests[i].keylen; 
     668        return (0); 
     669} 
     670 
     671 
     672static int cryptodev_digest_init(EVP_MD_CTX *ctx) 
     673{ 
     674        struct dev_crypto_state *state = ctx->md_data; 
     675        struct session_op *sess = &state->d_sess; 
     676        int digest; 
     677 
     678        if ((digest = digest_nid_to_cryptodev(ctx->digest->type)) == NID_undef){ 
     679                fprintf(stderr, "cryptodev_digest_init: Can't get digest \n"); 
     680                return (0); 
     681        } 
     682 
     683        memset(state, 0, sizeof(struct dev_crypto_state)); 
     684 
     685        if ((state->d_fd = get_dev_crypto()) < 0) { 
     686                fprintf(stderr, "cryptodev_digest_init: Can't get Dev \n"); 
     687                return (0); 
     688        } 
     689 
     690        sess->mackey = state->dummy_mac_key; 
     691        sess->mackeylen = digest_key_length(ctx->digest->type); 
     692        sess->mac = digest; 
     693 
     694        if (ioctl(state->d_fd, CIOCGSESSION, sess) < 0) { 
     695                close(state->d_fd); 
     696                state->d_fd = -1; 
     697                fprintf(stderr, "cryptodev_digest_init: Open session failed\n"); 
     698                return (0); 
     699        } 
     700 
     701        return (1); 
     702} 
     703 
     704static int cryptodev_digest_update(EVP_MD_CTX *ctx, const void *data, 
     705                size_t count) 
     706{ 
     707        struct crypt_op cryp; 
     708        struct dev_crypto_state *state = ctx->md_data; 
     709        struct session_op *sess = &state->d_sess; 
     710 
     711        if (!data || state->d_fd < 0) { 
     712                fprintf(stderr, "cryptodev_digest_update: illegal inputs \n"); 
     713                return (0); 
     714        } 
     715 
     716        if (!count) { 
     717                return (0); 
     718        } 
     719 
     720        if (!(ctx->flags & EVP_MD_CTX_FLAG_ONESHOT)) { 
     721                /* if application doesn't support one buffer */ 
     722                state->mac_data = OPENSSL_realloc(state->mac_data, state->mac_len + count); 
     723 
     724                if (!state->mac_data) { 
     725                        fprintf(stderr, "cryptodev_digest_update: realloc failed\n"); 
     726                        return (0); 
     727                } 
     728 
     729                memcpy(state->mac_data + state->mac_len, data, count); 
     730                state->mac_len += count; 
     731         
     732                return (1); 
     733        } 
     734 
     735        memset(&cryp, 0, sizeof(cryp)); 
     736 
     737        cryp.ses = sess->ses; 
     738        cryp.flags = 0; 
     739        cryp.len = count; 
     740        cryp.src = (caddr_t) data; 
     741        cryp.dst = NULL; 
     742        cryp.mac = state->digest_res; 
     743        if (ioctl(state->d_fd, CIOCCRYPT, &cryp) < 0) { 
     744                fprintf(stderr, "cryptodev_digest_update: digest failed\n"); 
     745                return (0); 
     746        } 
     747        return (1); 
     748} 
     749 
     750 
     751static int cryptodev_digest_final(EVP_MD_CTX *ctx, unsigned char *md) 
     752{ 
     753        struct crypt_op cryp; 
     754        struct dev_crypto_state *state = ctx->md_data; 
     755        struct session_op *sess = &state->d_sess; 
     756 
     757        int ret = 1; 
     758 
     759        if (!md || state->d_fd < 0) { 
     760                fprintf(stderr, "cryptodev_digest_final: illegal input\n"); 
     761                return(0); 
     762        } 
     763 
     764        if (! (ctx->flags & EVP_MD_CTX_FLAG_ONESHOT) ) { 
     765                /* if application doesn't support one buffer */ 
     766                memset(&cryp, 0, sizeof(cryp)); 
     767 
     768                cryp.ses = sess->ses; 
     769                cryp.flags = 0; 
     770                cryp.len = state->mac_len; 
     771                cryp.src = state->mac_data; 
     772                cryp.dst = NULL; 
     773                cryp.mac = md; 
     774 
     775                if (ioctl(state->d_fd, CIOCCRYPT, &cryp) < 0) { 
     776                        fprintf(stderr, "cryptodev_digest_final: digest failed\n"); 
     777                        return (0); 
     778                } 
     779 
     780                return 1; 
     781        } 
     782 
     783        memcpy(md, state->digest_res, ctx->digest->md_size); 
     784 
     785        return (ret); 
     786} 
     787 
     788 
     789static int cryptodev_digest_cleanup(EVP_MD_CTX *ctx) 
     790{ 
     791        int ret = 1; 
     792        struct dev_crypto_state *state = ctx->md_data; 
     793        struct session_op *sess = &state->d_sess; 
     794 
     795        if (state->d_fd < 0) { 
     796                fprintf(stderr, "cryptodev_digest_cleanup: illegal input\n"); 
     797                return (0); 
     798        } 
     799 
     800        if (state->mac_data) { 
     801                OPENSSL_free(state->mac_data); 
     802                state->mac_data = NULL; 
     803                state->mac_len = 0; 
     804        } 
     805 
     806        if (state->copy) 
     807                return 1; 
     808 
     809        if (ioctl(state->d_fd, CIOCFSESSION, &sess->ses) < 0) { 
     810                fprintf(stderr, "cryptodev_digest_cleanup: failed to close session\n"); 
     811                ret = 0; 
     812        } else { 
     813                ret = 1; 
     814        } 
     815        close(state->d_fd);      
     816        state->d_fd = -1; 
     817 
     818        return (ret); 
     819} 
     820 
     821static int cryptodev_digest_copy(EVP_MD_CTX *to,const EVP_MD_CTX *from) 
     822{ 
     823        struct dev_crypto_state *fstate = from->md_data; 
     824        struct dev_crypto_state *dstate = to->md_data; 
     825 
     826        memcpy(dstate, fstate, sizeof(struct dev_crypto_state)); 
     827 
     828        if (fstate->mac_len != 0) { 
     829                dstate->mac_data = OPENSSL_malloc(fstate->mac_len); 
     830                memcpy(dstate->mac_data, fstate->mac_data, fstate->mac_len); 
     831        } 
     832 
     833        dstate->copy = 1; 
     834 
     835        return 1; 
     836} 
     837 
     838 
     839const EVP_MD cryptodev_sha1 = { 
     840        NID_sha1, 
     841        NID_undef,  
     842        SHA_DIGEST_LENGTH,  
     843        EVP_MD_FLAG_ONESHOT, 
     844        cryptodev_digest_init, 
     845        cryptodev_digest_update, 
     846        cryptodev_digest_final, 
     847        cryptodev_digest_copy, 
     848        cryptodev_digest_cleanup, 
     849        EVP_PKEY_NULL_method, 
     850        SHA_CBLOCK, 
     851        sizeof(struct dev_crypto_state), 
     852}; 
     853 
     854const EVP_MD cryptodev_md5 = { 
     855        NID_md5, 
     856        NID_undef,  
     857        16 /* MD5_DIGEST_LENGTH */,  
     858        EVP_MD_FLAG_ONESHOT, 
     859        cryptodev_digest_init, 
     860        cryptodev_digest_update, 
     861        cryptodev_digest_final, 
     862        cryptodev_digest_copy, 
     863        cryptodev_digest_cleanup, 
     864        EVP_PKEY_NULL_method, 
     865        64 /* MD5_CBLOCK */, 
     866        sizeof(struct dev_crypto_state), 
     867}; 
     868 
     869#endif /* USE_CRYPTODEV_DIGESTS */ 
     870 
     871 
    610872static int 
    611873cryptodev_engine_digests(ENGINE *e, const EVP_MD **digest, 
    612874    const int **nids, int nid) 
    cryptodev_engine_digests(ENGINE *e, cons 
    615877                return (cryptodev_usable_digests(nids)); 
    616878 
    617879        switch (nid) { 
     880#ifdef USE_CRYPTODEV_DIGESTS 
    618881        case NID_md5: 
    619                 *digest = NULL; /* need to make a clean md5 critter */ 
     882                *digest = &cryptodev_md5;  
    620883                break; 
     884        case NID_sha1: 
     885                *digest = &cryptodev_sha1; 
     886                break; 
    621887        default: 
     888#endif /* USE_CRYPTODEV_DIGESTS */ 
    622889                *digest = NULL; 
    623890                break; 
    624891        } 
    bn2crparam(const BIGNUM *a, struct crpar 
    646913        b = malloc(bytes); 
    647914        if (b == NULL) 
    648915                return (1); 
     916        memset(b, 0, bytes); 
    649917 
    650918        crp->crp_p = (char *)b; 
    651919        crp->crp_nbits = bits; 
    zapparams(struct crypt_kop *kop) 
    690958{ 
    691959        int i; 
    692960 
    693         for (i = 0; i <= kop->crk_iparams + kop->crk_oparams; i++) { 
     961        for (i = 0; i < kop->crk_iparams + kop->crk_oparams; i++) { 
    694962                if (kop->crk_param[i].crp_p) 
    695963                        free(kop->crk_param[i].crp_p); 
    696964                kop->crk_param[i].crp_p = NULL; 
    static int 
    7761044cryptodev_rsa_nocrt_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx) 
    7771045{ 
    7781046        int r; 
    779  
    7801047        r = cryptodev_bn_mod_exp(r0, I, rsa->d, rsa->n, ctx, NULL); 
    7811048        return (r); 
    7821049} 
    cryptodev_dsa_do_sign(const unsigned cha 
    9201187                const DSA_METHOD *meth = DSA_OpenSSL(); 
    9211188                BN_free(r); 
    9221189                BN_free(s); 
     1190                fprintf(stderr, "cryptodev_asym: CRK_DSA_SIGN %s failed, " 
     1191                        "Running in software\n", errno==kop.crk_status ? 
     1192                        "hardware operation" : "asym process"); 
    9231193                dsaret = (meth->dsa_do_sign)(dgst, dlen, dsa); 
    9241194        } 
    9251195err: 
    cryptodev_dsa_verify(const unsigned char 
    9611231        } else { 
    9621232                const DSA_METHOD *meth = DSA_OpenSSL(); 
    9631233 
     1234                fprintf(stderr, "cryptodev_asym: CRK_DSA_VERIFY %s failed, " 
     1235                        "Running in software\n", errno==kop.crk_status ? 
     1236                        "hardware operation" : "asym process"); 
    9641237                dsaret = (meth->dsa_do_verify)(dgst, dlen, sig, dsa); 
    9651238        } 
    9661239err: 
    static int 
    9941267cryptodev_dh_compute_key(unsigned char *key, const BIGNUM *pub_key, DH *dh) 
    9951268{ 
    9961269        struct crypt_kop kop; 
    997         int dhret = 1; 
    998         int fd, keylen; 
     1270        int dhret = -1; 
     1271        int fd, keybits; 
    9991272 
    10001273        if ((fd = get_asym_dev_crypto()) < 0) { 
    10011274                const DH_METHOD *meth = DH_OpenSSL(); 
    cryptodev_dh_compute_key(unsigned char * 
    10031276                return ((meth->compute_key)(key, pub_key, dh)); 
    10041277        } 
    10051278 
    1006         keylen = BN_num_bits(dh->p); 
     1279        keybits = BN_num_bits(dh->p); 
    10071280 
    10081281        memset(&kop, 0, sizeof kop); 
    10091282        kop.crk_op = CRK_DH_COMPUTE_KEY; 
    cryptodev_dh_compute_key(unsigned char * 
    10181291        kop.crk_iparams = 3; 
    10191292 
    10201293        kop.crk_param[3].crp_p = (char *)key; 
    1021         kop.crk_param[3].crp_nbits = keylen * 8; 
     1294        kop.crk_param[3].crp_nbits = keybits; 
    10221295        kop.crk_oparams = 1; 
    10231296 
    10241297        if (ioctl(fd, CIOCKEY, &kop) == -1) { 
    10251298                const DH_METHOD *meth = DH_OpenSSL(); 
    10261299 
     1300                fprintf(stderr, "cryptodev_asym: CRK_DH_COMPUTE_KEY %s failed, " 
     1301                        "Running in software\n", errno==kop.crk_status ? 
     1302                        "hardware operation" : "asym process"); 
    10271303                dhret = (meth->compute_key)(key, pub_key, dh); 
    1028         } 
     1304        } else 
     1305                dhret = (keybits + 7) / 8; 
    10291306err: 
    10301307        kop.crk_param[3].crp_p = NULL; 
    10311308        zapparams(&kop); 
  • crypto/engine/engine.h

    a b typedef int (*dynamic_bind_engine)(ENGIN 
    705705 * values. */ 
    706706void *ENGINE_get_static_state(void); 
    707707 
    708 #if defined(__OpenBSD__) || defined(__FreeBSD__) 
     708#if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(HAVE_CRYPTODEV) 
    709709void ENGINE_setup_bsd_cryptodev(void); 
    710710#endif 
    711711 
  • crypto/evp/c_all.c

    a b void OPENSSL_add_all_algorithms_noconf(v 
    8383        OpenSSL_add_all_ciphers(); 
    8484        OpenSSL_add_all_digests(); 
    8585#ifndef OPENSSL_NO_ENGINE 
    86 # if defined(__OpenBSD__) || defined(__FreeBSD__) 
     86# if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(HAVE_CRYPTODEV) 
    8787        ENGINE_setup_bsd_cryptodev(); 
    8888# endif 
    8989#endif 
  • crypto/evp/c_alld.c

    a b void OpenSSL_add_all_digests(void) 
    7878        EVP_add_digest(EVP_dss()); 
    7979#endif 
    8080#endif 
    81 #ifndef OPENSSL_NO_SHA 
     81#if !defined(OPENSSL_NO_SHA) && !defined(OPENSSL_NO_SHA1) 
    8282        EVP_add_digest(EVP_sha1()); 
    8383        EVP_add_digest_alias(SN_sha1,"ssl3-sha1"); 
    8484        EVP_add_digest_alias(SN_sha1WithRSAEncryption,SN_sha1WithRSA); 
  • engines/Makefile

    a b install: 
    9797                        ( echo installing $$l; \ 
    9898                          if [ "$(PLATFORM)" != "Cygwin" ]; then \ 
    9999                                case "$(CFLAGS)" in \ 
     100                                *OPENSSL_NO_HW*)        continue;;      \ 
    100101                                *DSO_DLFCN*)    sfx="so";;      \ 
    101102                                *DSO_DL*)       sfx="sl";;      \ 
    102103                                *)              sfx="bad";;     \ 
Note: See TracBrowser for help on using the repository browser.