source: trunk/package/openssl/patches/200-ocf-20080917.patch @ 19368

Last change on this file since 19368 was 19368, checked in by nbd, 6 years ago

openssl: refresh patches

File size: 36.0 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=( 
    547549##### Compaq Non-Stop Kernel (Tandem) 
    548550"tandem-c89","c89:-Ww -D__TANDEM -D_XOPEN_SOURCE -D_XOPEN_SOURCE_EXTENDED=1 -D_TANDEM_SOURCE -DB_ENDIAN::(unknown):::THIRTY_TWO_BIT:::", 
    549551 
     552# uClinux 
     553"uClinux-dist","$ENV{'CC'}:\$(CFLAGS)::-D_REENTRANT::\$(LDFLAGS) \$(LDLIBS):BN_LLONG::::::::::::\$(LIBSSL_dlfcn):linux-shared:-fPIC:-shared:.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR):$ENV{'RANLIB'}", 
     554 
    550555); 
    551556 
    552557my @MK1MF_Builds=qw(VC-WIN64I VC-WIN64A 
    my $montasm=1; # but "no-montasm" is d 
    601606my $no_asm=0; 
    602607my $no_dso=0; 
    603608my $no_gmp=0; 
     609my $have_cryptodev=0; 
     610my $use_cryptodev_digests=0; 
    604611my @skip=(); 
    605612my $Makefile="Makefile"; 
    606613my $des_locl="crypto/des/des_locl.h"; 
    PROCESS_ARGS: 
    749756                        { 
    750757                        exit(&test_sanity()); 
    751758                        } 
     759                elsif (/^--with-cryptodev$/) 
     760                        { 
     761                                $have_cryptodev = 1; 
     762                        } 
     763                elsif (/^--with-cryptodev-digests$/) 
     764                        { 
     765                                $use_cryptodev_digests = 1; 
     766                        } 
    752767                elsif (/^reconfigure/ || /^reconf/) 
    753768                        { 
    754769                        if (open(IN,"<$Makefile")) 
    foreach (sort (keys %disabled)) 
    10371052                        print " OPENSSL_NO_$ALGO"; 
    10381053                 
    10391054                        if (/^err$/)    { $flags .= "-DOPENSSL_NO_ERR "; } 
     1055                        elsif (/^hw$/)  { $flags .= "-DOPENSSL_NO_HW "; } 
    10401056                        elsif (/^asm$/) { $no_asm = 1; } 
    10411057                        } 
    10421058                else 
    if (!$no_krb5) 
    11611177                   $withargs{"krb5-dir"} ne ""; 
    11621178        } 
    11631179 
     1180# enable the linux cryptodev (ocf-linux) support 
     1181if ($have_cryptodev) 
     1182        { 
     1183        if ($use_cryptodev_digests) 
     1184                { 
     1185                $cflags = "-DUSE_CRYPTODEV_DIGESTS $cflags"; 
     1186                } 
     1187        $cflags = "-DHAVE_CRYPTODEV $cflags"; 
     1188        } 
     1189 
    11641190# The DSO code currently always implements all functions so that no 
    11651191# applications will have to worry about that from a compilation point 
    11661192# 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: 
    502502 
    503503links: 
    504504        @$(PERL) $(TOP)/util/mkdir-p.pl include/openssl 
    505         @$(PERL) $(TOP)/util/mklink.pl include/openssl $(EXHEADER) 
     505        @$(PERL) $(TOP)/util/mklink.pl include/openssl $(HEADER) $(EXHEADER) 
    506506        @set -e; target=links; $(RECURSIVE_BUILD_CMD) 
    507507        @if [ -z "$(FIPSCANLIB)" ]; then \ 
    508508                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 done 
    4848 
    4949# First get uname entries that we use below 
    5050 
    51 MACHINE=`(uname -m) 2>/dev/null` || MACHINE="unknown" 
    52 RELEASE=`(uname -r) 2>/dev/null` || RELEASE="unknown" 
    53 SYSTEM=`(uname -s) 2>/dev/null`  || SYSTEM="unknown" 
    54 VERSION=`(uname -v) 2>/dev/null` || VERSION="unknown" 
     51[ "$MACHINE" ] || MACHINE=`(uname -m) 2>/dev/null` || MACHINE="unknown" 
     52[ "$RELEASE" ] || RELEASE=`(uname -r) 2>/dev/null` || RELEASE="unknown" 
     53[ "$SYSTEM" ]  || SYSTEM=`(uname -s) 2>/dev/null`  || SYSTEM="unknown" 
     54[ "$VERSION" ] || VERSION=`(uname -v) 2>/dev/null` || VERSION="unknown" 
    5555 
    5656 
    5757# Now test for ISC and SCO, since it is has a braindamaged uname. 
    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 
    401401 
    402402# figure out if gcc is available and if so we use it otherwise 
    403403# we fallback to whatever cc does on the system 
    404 GCCVER=`(gcc -dumpversion) 2>/dev/null` 
     404CC="${CC:-gcc}" 
     405GCCVER=`(${CC} -dumpversion) 2>/dev/null` 
    405406if [ "$GCCVER" != "" ]; then 
    406   CC=gcc 
    407407  # then strip off whatever prefix egcs prepends the number with... 
    408408  # Hopefully, this will work for any future prefixes as well. 
    409409  GCCVER=`echo $GCCVER | LC_ALL=C sed 's/^[a-zA-Z]*\-//'` 
    if [ "$GCCVER" != "" ]; then 
    413413  # peak single digit before and after first dot, e.g. 2.95.1 gives 29 
    414414  GCCVER=`echo $GCCVER | sed 's/\([0-9]\)\.\([0-9]\).*/\1\2/'` 
    415415else 
    416   CC=cc 
     416  CC="${CC:-cc}" 
    417417fi 
    418418 
    419419# Only set CC if not supplied already 
    echo Operating system: $GUESSOS 
    493493# script above so we end up with values in vars but that would take 
    494494# more time that I want to waste at the moment 
    495495case "$GUESSOS" in 
     496  uClinux*) 
     497    OUT=uClinux-dist 
     498        ;; 
    496499  mips2-sgi-irix) 
    497500        CPU=`(hinv -t cpu) 2>/dev/null | head -1 | sed 's/^CPU:[^R]*R\([0-9]*\).*/\1/'` 
    498501        CPU=${CPU:-0} 
  • new file makefile-uclinuxdist

    - +  
     1# 
     2# this makefile gets recursed through by various bits of the build 
     3# so we need to only setup some things when invoked from outside 
     4# this directory. 
     5# 
     6# davidm@snapgear.com 
     7# 
     8 
     9IN_LIBSSL := true 
     10export IN_LIBSSL 
     11 
     12CONFIG_OPTS  := --prefix=// --install_prefix=$(shell pwd)/build/install 
     13 
     14ifdef CONFIG_USER_FLATFSD_FLATFSD 
     15CONFIG_OPTS += --openssldir=/etc/config 
     16else 
     17CONFIG_OPTS += --openssldir=/etc 
     18endif 
     19ifdef DISABLE_SHARED_SSL 
     20CONFIG_OPTS += no-shared 
     21else 
     22CONFIG_OPTS += shared 
     23endif 
     24 
     25CONFIG_OPTS += no-rc2 
     26CONFIG_OPTS += no-krb5 
     27CONFIG_OPTS += no-rc5 
     28CONFIG_OPTS += no-md2 
     29CONFIG_OPTS += no-idea 
     30#CONFIG_OPTS += no-pem 
     31#CONFIG_OPTS += no-md5 
     32#CONFIG_OPTS += no-sha 
     33#CONFIG_OPTS += no-hmac 
     34#CONFIG_OPTS += no-des 
     35#CONFIG_OPTS += no-aes 
     36#CONFIG_OPTS += no-bn 
     37CONFIG_OPTS += no-ec 
     38#CONFIG_OPTS += no-rsa 
     39#CONFIG_OPTS += no-dsa 
     40CONFIG_OPTS += no-ecdsa 
     41#CONFIG_OPTS += no-dh 
     42CONFIG_OPTS += no-ecdh 
     43CONFIG_OPTS += no-dso 
     44#CONFIG_OPTS += no-engine 
     45#CONFIG_OPTS += no-buffer 
     46#CONFIG_OPTS += no-bio 
     47#CONFIG_OPTS += no-stack 
     48#CONFIG_OPTS += no-lhash 
     49#CONFIG_OPTS += no-rand 
     50CONFIG_OPTS += no-err 
     51#CONFIG_OPTS += no-evp 
     52#CONFIG_OPTS += no-asn1 
     53#CONFIG_OPTS += no-x509 
     54#CONFIG_OPTS += no-x509v3 
     55#CONFIG_OPTS += no-txt_db 
     56#CONFIG_OPTS += no-pkcs7 
     57#CONFIG_OPTS += no-pkcs12 
     58#CONFIG_OPTS += no-comp 
     59#CONFIG_OPTS += no-ocsp 
     60#CONFIG_OPTS += no-ui 
     61#CONFIG_OPTS += no-store 
     62CONFIG_OPTS += no-pqueue 
     63 
     64# REVISIT: It would be better to have OPENSSL config options 
     65# which turn on this support as needed 
     66ifeq ($(CONFIG_USER_NESSUS_NASL)$(CONFIG_USER_SSH_SSH),) 
     67CONFIG_OPTS += no-ripemd 
     68CONFIG_OPTS += no-cast 
     69CONFIG_OPTS += no-rc4 
     70endif 
     71 
     72ifeq ($(CONFIG_USER_NESSUS_NASL)$(CONFIG_USER_SSH_SSH)$(CONFIG_PROP_SSCEP_SSCEP),) 
     73CONFIG_OPTS += no-bf 
     74endif 
     75 
     76ifeq ($(CONFIG_USER_OPENVPN_OPENVPN)$(CONFIG_USER_WGET),) 
     77CONFIG_OPTS += no-md4 
     78endif 
     79 
     80ifdef CONFIG_OCF_OCF 
     81CONFIG_OPTS += --with-cryptodev 
     82#CONFIG_OPTS += --with-cryptodev-digests 
     83endif 
     84 
     85# 
     86# if you want engines (they are dl loaded),  a few things 
     87# need to be setup,  you will also need to mod everything 
     88# to link against -ldl if it uses libcrypto.  By default we 
     89# disable it (cryptodev suport is still included). 
     90# 
     91ifdef YOU_WANT_DYNAMIC_HW_ENGINES_ENABLED 
     92LIBSSL_dlfcn = dlfcn 
     93else 
     94CONFIG_OPTS += no-hw 
     95LIBSSL_dlfcn = 
     96endif 
     97 
     98# 
     99# our libs aren't in the default location yet 
     100# 
     101LDFLAGS += -L$(ROOTDIR)/lib/libssl/build 
     102export LDFLAGS 
     103 
     104all: build/configured 
     105        $(MAKE) -C build 
     106        $(MAKE) -C build install_sw 
     107 
     108build/configured: makefile config Configure 
     109        rm -rf build 
     110        find . -type d > .dirs 
     111        find . ! -type d | grep -v ./makefile > .files 
     112        while read t; do mkdir -p build/$$t; done < .dirs 
     113        while read t; do ln -s `pwd`/$$t build/$$t; done < .files 
     114        rm -f .dirs .files 
     115        chmod +x build/config 
     116        cd build; MACHINE=uClinux-dist ./config $(CONFIG_OPTS) 
     117        $(MAKE) -C build depend 
     118        $(MAKE) -C build links 
     119        touch build/configured 
     120 
     121clean: 
     122        -rm -rf build 
     123 
     124romfs: 
     125        cd build/install/lib; \ 
     126        for i in *.so*; do \ 
     127                if [ -L $$i ]; then \ 
     128                        $(ROMFSINST) -s `find $$i -printf %l` /lib/$$i; \ 
     129                elif [ -f $$i ]; then \ 
     130                        $(ROMFSINST) /lib/$$i; \ 
     131                fi; \ 
     132        done 
     133 
     134romfs_user: 
     135        $(ROMFSINST) -e CONFIG_USER_OPENSSL_APPS build/install/bin/openssl /bin/openssl 
     136        # $(ROMFSINST) -e CONFIG_USER_OPENSSL_APPS build/install/bin/c_rehash /bin/c_rehash 
     137 
     138 
  • 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]={ 
    292292  "evp","sha256","sha512", 
    293293  "aes-128 ige","aes-192 ige","aes-256 ige"}; 
    294294static double results[ALGOR_NUM][SIZE_NUM]; 
    295 static int lengths[SIZE_NUM]={16,64,256,1024,8*1024}; 
     295static int lengths[SIZE_NUM]={16,64,256,1024,2*1024,4*1024}; 
    296296static double rsa_results[RSA_NUM][2]; 
    297297static double dsa_results[DSA_NUM][2]; 
    298298#ifndef OPENSSL_NO_ECDSA 
    static SIGRETTYPE sig_done(int sig) 
    328328#define START   0 
    329329#define STOP    1 
    330330 
     331#ifdef __linux__ 
     332/* 
     333 * record CPU usage as well 
     334 */ 
     335 
     336static int do_cpu = 0; 
     337 
     338struct cpu_stat { 
     339        unsigned int    user; 
     340        unsigned int    nice; 
     341        unsigned int    system; 
     342        unsigned int    idle; 
     343        unsigned int    total; 
     344}; 
     345 
     346static unsigned int cpu_usage[ALGOR_NUM][SIZE_NUM]; 
     347static unsigned int rsa_cpu_usage[RSA_NUM][2]; 
     348static unsigned int dsa_cpu_usage[DSA_NUM][2]; 
     349static struct cpu_stat cpu_start, cpu_finish; 
     350 
     351static void 
     352get_cpu(int s) 
     353{ 
     354        FILE *fp = NULL; 
     355        unsigned char   buf[80]; 
     356        struct cpu_stat *st = s == START ? &cpu_start : &cpu_finish; 
     357 
     358        memset(st, 0, sizeof(*st)); 
     359 
     360        if (fp == NULL) 
     361                fp = fopen("/proc/stat", "r"); 
     362        if (!fp) 
     363                return; 
     364        if (fseek(fp, 0, SEEK_SET) == -1) { 
     365                fclose(fp); 
     366                return; 
     367        } 
     368        fscanf(fp, "%s %d %d %d %d", &buf[0], &st->user, &st->nice, 
     369                &st->system, &st->idle); 
     370        st->total = st->user + st->nice + st->system + st->idle; 
     371        fclose(fp); 
     372} 
     373 
     374static unsigned int 
     375calc_cpu() 
     376{ 
     377        unsigned int total, res; 
     378 
     379        total  = cpu_finish.total - cpu_start.total; 
     380        if (total <= 0) 
     381                return 0; 
     382#if 1 // busy 
     383        res   = ((cpu_finish.system + cpu_finish.user + cpu_finish.nice) - 
     384                         (cpu_start.system + cpu_start.user + cpu_start.nice)) * 
     385                         100 / total; 
     386#endif 
     387#if 0 // system 
     388        res   = (cpu_finish.system - cpu_start.system) * 100 / total; 
     389#endif 
     390#if 0 // user 
     391        res   = (cpu_finish.user   - cpu_start.user)   * 100 / total; 
     392#endif 
     393#if 0 // nice 
     394        res   = (cpu_finish.nice   - cpu_start.nice)   * 100 / total; 
     395#endif 
     396#if 0 // idle 
     397        res   = (cpu_finish.idle   - cpu_start.idle)   * 100 / total; 
     398#endif 
     399        return(res); 
     400} 
     401 
     402#endif 
     403 
    331404#if defined(OPENSSL_SYS_NETWARE) 
    332405 
    333406   /* for NetWare the best we can do is use clock() which returns the 
    static double Time_F(int s) 
    358431        { 
    359432        double ret; 
    360433 
     434#ifdef __linux__ 
     435        if (do_cpu) 
     436                get_cpu(s); 
     437#endif 
     438 
    361439#ifdef USE_TOD 
    362440        if(usertime) 
    363441                { 
    int MAIN(int argc, char **argv) 
    832910                        j--;    /* Otherwise, -elapsed gets confused with 
    833911                                   an algorithm. */ 
    834912                        } 
     913#ifdef __linux__ 
     914                else if ((argc > 0) && (strcmp(*argv,"-cpu") == 0)) 
     915                        { 
     916                        do_cpu = 1; 
     917                        j--;    /* Otherwise, -cpu gets confused with 
     918                                   an algorithm. */ 
     919                        } 
     920#endif 
    835921                else if ((argc > 0) && (strcmp(*argv,"-evp") == 0)) 
    836922                        { 
    837923                        argc--; 
    int MAIN(int argc, char **argv) 
    12601346#ifdef HAVE_FORK 
    12611347                        BIO_printf(bio_err,"-multi n        run n benchmarks in parallel.\n"); 
    12621348#endif 
     1349#ifdef __linux__ 
     1350                        BIO_printf(bio_err,"-cpu            calculate cpu utilisation.\n"); 
     1351#endif 
    12631352                        goto end; 
    12641353                        } 
    12651354                argc--; 
    int MAIN(int argc, char **argv) 
    12671356                j++; 
    12681357                } 
    12691358 
    1270 #ifdef HAVE_FORK 
    1271         if(multi && do_multi(multi)) 
    1272                 goto show_res; 
    1273 #endif 
    1274  
    12751359        if (j == 0) 
    12761360                { 
    12771361                for (i=0; i<ALGOR_NUM; i++) 
    int MAIN(int argc, char **argv) 
    16041688        signal(SIGALRM,sig_done); 
    16051689#endif /* SIGALRM */ 
    16061690 
     1691#ifdef HAVE_FORK /* DM */ 
     1692        if(multi && do_multi(multi)) 
     1693                goto show_res; 
     1694#endif 
     1695 
    16071696#ifndef OPENSSL_NO_MD2 
    16081697        if (doit[D_MD2]) 
    16091698                { 
    int MAIN(int argc, char **argv) 
    20332122                                /* -O3 -fschedule-insns messes up an 
    20342123                                 * optimization here!  names[D_EVP] 
    20352124                                 * somehow becomes NULL */ 
    2036                                 print_message(names[D_EVP],save_count, 
    2037                                         lengths[j]); 
    20382125 
    20392126                                EVP_CIPHER_CTX_init(&ctx); 
    20402127                                if(decrypt) 
    int MAIN(int argc, char **argv) 
    20432130                                        EVP_EncryptInit_ex(&ctx,evp_cipher,NULL,key16,iv); 
    20442131                                EVP_CIPHER_CTX_set_padding(&ctx, 0); 
    20452132 
     2133                                print_message(names[D_EVP],save_count, 
     2134                                        lengths[j]); 
     2135 
    20462136                                Time_F(START); 
    20472137                                if(decrypt) 
    20482138                                        for (count=0,run=1; COND(save_count*4*lengths[0]/lengths[j]); count++) 
    int MAIN(int argc, char **argv) 
    21072197                                        } 
    21082198                                } 
    21092199                        d=Time_F(STOP); 
     2200                        if (do_cpu) 
     2201                                rsa_cpu_usage[j][0] = calc_cpu(); 
    21102202                        BIO_printf(bio_err,mr ? "+R1:%ld:%d:%.2f\n" 
    21112203                                   : "%ld %d bit private RSA's in %.2fs\n", 
    21122204                                   count,rsa_bits[j],d); 
    int MAIN(int argc, char **argv) 
    21422234                                        } 
    21432235                                } 
    21442236                        d=Time_F(STOP); 
     2237                        if (do_cpu) 
     2238                                rsa_cpu_usage[j][1] = calc_cpu(); 
    21452239                        BIO_printf(bio_err,mr ? "+R2:%ld:%d:%.2f\n" 
    21462240                                   : "%ld %d bit public RSA's in %.2fs\n", 
    21472241                                   count,rsa_bits[j],d); 
    int MAIN(int argc, char **argv) 
    22012295                                        } 
    22022296                                } 
    22032297                        d=Time_F(STOP); 
     2298                        if (do_cpu) 
     2299                                dsa_cpu_usage[j][0] = calc_cpu(); 
    22042300                        BIO_printf(bio_err,mr ? "+R3:%ld:%d:%.2f\n" 
    22052301                                   : "%ld %d bit DSA signs in %.2fs\n", 
    22062302                                   count,dsa_bits[j],d); 
    int MAIN(int argc, char **argv) 
    22362332                                        } 
    22372333                                } 
    22382334                        d=Time_F(STOP); 
     2335                        if (do_cpu) 
     2336                                dsa_cpu_usage[j][1] = calc_cpu(); 
    22392337                        BIO_printf(bio_err,mr ? "+R4:%ld:%d:%.2f\n" 
    22402338                                   : "%ld %d bit DSA verify in %.2fs\n", 
    22412339                                   count,dsa_bits[j],d); 
    show_res: 
    25302628                        fprintf(stdout,"The 'numbers' are in 1000s of bytes per second processed.\n");  
    25312629                        fprintf(stdout,"type        "); 
    25322630                        } 
    2533                 for (j=0;  j<SIZE_NUM; j++) 
     2631                for (j=0;  j<SIZE_NUM; j++) { 
    25342632                        fprintf(stdout,mr ? ":%d" : "%7d bytes",lengths[j]); 
     2633                        if (do_cpu && !mr) 
     2634                                fprintf(stdout, " /cpu"); 
     2635                } 
    25352636                fprintf(stdout,"\n"); 
    25362637                } 
    25372638 
    25382639        for (k=0; k<ALGOR_NUM; k++) 
    25392640                { 
    25402641                if (!doit[k]) continue; 
     2642                if (k == D_EVP) { 
     2643                        if (evp_cipher) 
     2644                                names[D_EVP]=OBJ_nid2ln(evp_cipher->nid); 
     2645                        else 
     2646                                names[D_EVP]=OBJ_nid2ln(evp_md->type); 
     2647                } 
    25412648                if(mr) 
    25422649                        fprintf(stdout,"+F:%d:%s",k,names[k]); 
    25432650                else 
    show_res: 
    25482655                                fprintf(stdout," %11.2fk",results[k][j]/1e3); 
    25492656                        else 
    25502657                                fprintf(stdout,mr ? ":%.2f" : " %11.2f ",results[k][j]); 
     2658                        if (do_cpu) 
     2659                                fprintf(stdout, mr ? "/%d" : "/%%%-3d", cpu_usage[k][j]); 
    25512660                        } 
    25522661                fprintf(stdout,"\n"); 
    25532662                } 
    show_res: 
    25622671                        j=0; 
    25632672                        } 
    25642673                if(mr) 
    2565                         fprintf(stdout,"+F2:%u:%u:%f:%f\n", 
    2566                                 k,rsa_bits[k],rsa_results[k][0], 
    2567                                 rsa_results[k][1]); 
    2568                 else 
    2569                         fprintf(stdout,"rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n", 
    2570                                 rsa_bits[k],rsa_results[k][0],rsa_results[k][1], 
    2571                                 1.0/rsa_results[k][0],1.0/rsa_results[k][1]); 
     2674                        fprintf(stdout,"+F2:%u:%u:%f", k,rsa_bits[k],rsa_results[k][0]); 
     2675                else 
     2676                        fprintf(stdout,"rsa %4u bits %8.6fs",rsa_bits[k],rsa_results[k][0]); 
     2677                if (do_cpu) 
     2678                        fprintf(stdout, mr ? "/%d": "/%%%-3d", rsa_cpu_usage[k][0]); 
     2679                fprintf(stdout, mr ? ":%f" : " %8.6fs", rsa_results[k][1]); 
     2680                if (do_cpu) 
     2681                        fprintf(stdout, mr ? "/%d": "/%%%-3d", rsa_cpu_usage[k][1]); 
     2682                if(!mr) 
     2683                        fprintf(stdout, " %8.1f %8.1f", 
     2684                                        1.0/rsa_results[k][0],1.0/rsa_results[k][1]); 
     2685                fprintf(stdout, "\n"); 
    25722686                } 
    25732687#endif 
    25742688#ifndef OPENSSL_NO_DSA 
    show_res: 
    25822696                        j=0; 
    25832697                        } 
    25842698                if(mr) 
    2585                         fprintf(stdout,"+F3:%u:%u:%f:%f\n", 
    2586                                 k,dsa_bits[k],dsa_results[k][0],dsa_results[k][1]); 
     2699                        fprintf(stdout,"+F3:%u:%u:%f", k,dsa_bits[k],dsa_results[k][0]); 
    25872700                else 
    2588                         fprintf(stdout,"dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n", 
    2589                                 dsa_bits[k],dsa_results[k][0],dsa_results[k][1], 
    2590                                 1.0/dsa_results[k][0],1.0/dsa_results[k][1]); 
     2701                        fprintf(stdout,"dsa %4u bits %8.6fs",dsa_bits[k],dsa_results[k][0]); 
     2702                if (do_cpu) 
     2703                        fprintf(stdout, mr ? "/%d": "/%%%-3d", dsa_cpu_usage[k][0]); 
     2704                fprintf(stdout, mr ? ":%f" : " %8.6fs", dsa_results[k][1]); 
     2705                if (do_cpu) 
     2706                        fprintf(stdout, mr ? "/%d": "/%%%-3d", dsa_cpu_usage[k][1]); 
     2707                if(!mr) 
     2708                        fprintf(stdout, " %8.1f %8.1f", 
     2709                                        1.0/dsa_results[k][0],1.0/dsa_results[k][1]); 
     2710                fprintf(stdout, "\n"); 
    25912711                } 
    25922712#endif 
    25932713#ifndef OPENSSL_NO_ECDSA 
    static void pkey_print_message(const cha 
    27122832 
    27132833static void print_result(int alg,int run_no,int count,double time_used) 
    27142834        { 
    2715         BIO_printf(bio_err,mr ? "+R:%d:%s:%f\n" 
    2716                    : "%d %s's in %.2fs\n",count,names[alg],time_used); 
     2835        if (do_cpu) 
     2836            cpu_usage[alg][run_no] = calc_cpu(); 
     2837        BIO_printf(bio_err,mr ? "+R:%ld:%s:%f\n" 
     2838                   : "%ld %s's in %.2fs\n",count,names[alg],time_used); 
    27172839        results[alg][run_no]=((double)count)/time_used*lengths[run_no]; 
    27182840        } 
    27192841 
    static int do_multi(int multi) 
    28082930                                p=buf+3; 
    28092931                                alg=atoi(sstrsep(&p,sep)); 
    28102932                                sstrsep(&p,sep); 
    2811                                 for(j=0 ; j < SIZE_NUM ; ++j) 
     2933                                for(j=0 ; j < SIZE_NUM ; ++j) { 
     2934                                        if (do_cpu && strchr(p, '/')) 
     2935                                                cpu_usage[alg][j] = atoi(strchr(p, '/') + 1); 
    28122936                                        results[alg][j]+=atof(sstrsep(&p,sep)); 
    28132937                                } 
    2814                         else if(!strncmp(buf,"+F2:",4)) 
    2815                                 { 
    2816                                 int k; 
    2817                                 double d; 
    2818                                  
    2819                                 p=buf+4; 
    2820                                 k=atoi(sstrsep(&p,sep)); 
    2821                                 sstrsep(&p,sep); 
    2822  
    2823                                 d=atof(sstrsep(&p,sep)); 
    2824                                 if(n) 
    2825                                         rsa_results[k][0]=1/(1/rsa_results[k][0]+1/d); 
    2826                                 else 
    2827                                         rsa_results[k][0]=d; 
    2828  
    2829                                 d=atof(sstrsep(&p,sep)); 
    2830                                 if(n) 
    2831                                         rsa_results[k][1]=1/(1/rsa_results[k][1]+1/d); 
    2832                                 else 
    2833                                         rsa_results[k][1]=d; 
    28342938                                } 
    28352939                        else if(!strncmp(buf,"+F2:",4)) 
    28362940                                { 
    static int do_multi(int multi) 
    28412945                                k=atoi(sstrsep(&p,sep)); 
    28422946                                sstrsep(&p,sep); 
    28432947 
     2948                                /* before we move the token along */ 
     2949                                if (do_cpu && strchr(p, '/')) 
     2950                                        rsa_cpu_usage[k][0] = atoi(strchr(p, '/') + 1); 
    28442951                                d=atof(sstrsep(&p,sep)); 
    28452952                                if(n) 
    28462953                                        rsa_results[k][0]=1/(1/rsa_results[k][0]+1/d); 
    28472954                                else 
    28482955                                        rsa_results[k][0]=d; 
    28492956 
     2957                                /* before we move the token along */ 
     2958                                if (do_cpu && strchr(p, '/')) 
     2959                                        rsa_cpu_usage[k][1] = atoi(strchr(p, '/') + 1); 
    28502960                                d=atof(sstrsep(&p,sep)); 
    28512961                                if(n) 
    28522962                                        rsa_results[k][1]=1/(1/rsa_results[k][1]+1/d); 
    static int do_multi(int multi) 
    28622972                                k=atoi(sstrsep(&p,sep)); 
    28632973                                sstrsep(&p,sep); 
    28642974 
     2975                                /* before we move the token along */ 
     2976                                if (do_cpu && strchr(p, '/')) 
     2977                                        dsa_cpu_usage[k][0] = atoi(strchr(p, '/') + 1); 
    28652978                                d=atof(sstrsep(&p,sep)); 
    28662979                                if(n) 
    28672980                                        dsa_results[k][0]=1/(1/dsa_results[k][0]+1/d); 
    28682981                                else 
    28692982                                        dsa_results[k][0]=d; 
    28702983 
     2984                                /* before we move the token along */ 
     2985                                if (do_cpu && strchr(p, '/')) 
     2986                                        dsa_cpu_usage[k][1] = atoi(strchr(p, '/') + 1); 
    28712987                                d=atof(sstrsep(&p,sep)); 
    28722988                                if(n) 
    28732989                                        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) 
    104104#endif 
    105105#endif 
    106106#ifndef OPENSSL_NO_HW 
    107 #if defined(__OpenBSD__) || defined(__FreeBSD__) 
     107#if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(HAVE_CRYPTODEV) 
    108108        ENGINE_load_cryptodev(); 
    109109#endif 
    110110#if defined(OPENSSL_SYS_WIN32) && !defined(OPENSSL_NO_CAPIENG) 
    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) 
    6868struct dev_crypto_state { 
    6969        struct session_op d_sess; 
    7070        int d_fd; 
     71 
     72#ifdef USE_CRYPTODEV_DIGESTS 
     73        char dummy_mac_key[20]; 
     74 
     75        unsigned char digest_res[20]; 
     76        char *mac_data; 
     77        int mac_len; 
     78 
     79        int copy; 
     80#endif 
    7181}; 
    7282 
    7383static u_int32_t cryptodev_asymfeat = 0; 
    static u_int32_t cryptodev_asymfeat = 0; 
    7585static int get_asym_dev_crypto(void); 
    7686static int open_dev_crypto(void); 
    7787static int get_dev_crypto(void); 
     88#if 0 
    7889static int cryptodev_max_iv(int cipher); 
    7990static int cryptodev_key_length_valid(int cipher, int len); 
    8091static int cipher_nid_to_cryptodev(int nid); 
     92#endif 
    8193static int get_cryptodev_ciphers(const int **cnids); 
    8294static int get_cryptodev_digests(const int **cnids); 
    8395static int cryptodev_usable_ciphers(const int **nids); 
    static int cryptodev_asym(struct crypt_k 
    100112static int cryptodev_bn_mod_exp(BIGNUM *r, const BIGNUM *a, 
    101113    const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx); 
    102114static int cryptodev_rsa_nocrt_mod_exp(BIGNUM *r0, const BIGNUM *I, 
    103     RSA *rsa); 
     115    RSA *rsa, BN_CTX *ctx); 
    104116static int cryptodev_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx); 
    105117static int cryptodev_dsa_bn_mod_exp(DSA *dsa, BIGNUM *r, BIGNUM *a, 
    106118    const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx); 
    static struct { 
    130142        int     ivmax; 
    131143        int     keylen; 
    132144} ciphers[] = { 
     145        { CRYPTO_ARC4,                  NID_rc4,                0,      16, }, 
    133146        { CRYPTO_DES_CBC,               NID_des_cbc,            8,       8, }, 
    134147        { CRYPTO_3DES_CBC,              NID_des_ede3_cbc,       8,      24, }, 
    135148        { CRYPTO_AES_CBC,               NID_aes_128_cbc,        16,     16, }, 
     149        { CRYPTO_AES_CBC,               NID_aes_192_cbc,        16,     24, }, 
     150        { CRYPTO_AES_CBC,               NID_aes_256_cbc,        16,     32, }, 
    136151        { CRYPTO_BLF_CBC,               NID_bf_cbc,             8,      16, }, 
    137152        { CRYPTO_CAST_CBC,              NID_cast5_cbc,          8,      16, }, 
    138153        { CRYPTO_SKIPJACK_CBC,          NID_undef,              0,       0, }, 
    static struct { 
    142157static struct { 
    143158        int     id; 
    144159        int     nid; 
     160        int     keylen; 
    145161} digests[] = { 
    146         { CRYPTO_SHA1_HMAC,             NID_hmacWithSHA1,       }, 
    147         { CRYPTO_RIPEMD160_HMAC,        NID_ripemd160,          }, 
    148         { CRYPTO_MD5_KPDK,              NID_undef,              }, 
    149         { CRYPTO_SHA1_KPDK,             NID_undef,              }, 
    150         { CRYPTO_MD5,                   NID_md5,                }, 
    151         { CRYPTO_SHA1,                  NID_undef,              }, 
    152         { 0,                            NID_undef,              }, 
     162        { CRYPTO_SHA1_HMAC,             NID_hmacWithSHA1,       20}, 
     163        { CRYPTO_RIPEMD160_HMAC,        NID_ripemd160,          16/*?*/}, 
     164        { CRYPTO_MD5_KPDK,              NID_undef,              0}, 
     165        { CRYPTO_SHA1_KPDK,             NID_undef,              0}, 
     166        { CRYPTO_MD5,                   NID_md5,                16}, 
     167        { CRYPTO_SHA1,                  NID_sha1,               20}, 
     168        { 0,                            NID_undef,              0}, 
    153169}; 
    154170 
    155171/* 
    open_dev_crypto(void) 
    176192static int 
    177193get_dev_crypto(void) 
    178194{ 
    179         int fd, retfd; 
     195        static int fd = -1; 
     196        int retfd; 
    180197 
    181         if ((fd = open_dev_crypto()) == -1) 
    182                 return (-1); 
     198        if (fd == -1) { 
     199                if ((fd = open_dev_crypto()) == -1) 
     200                        return (-1); 
     201                if (fcntl(fd, F_SETFD, 1) == -1) { 
     202                        close(fd); 
     203                        return (-1); 
     204                } 
     205        } 
    183206        if (ioctl(fd, CRIOGET, &retfd) == -1) 
    184207                return (-1); 
    185208 
    get_asym_dev_crypto(void) 
    202225        return fd; 
    203226} 
    204227 
     228#if 0 
    205229/* 
    206230 * XXXX this needs to be set for each alg - and determined from 
    207231 * a running card. 
    cipher_nid_to_cryptodev(int nid) 
    245269                        return (ciphers[i].id); 
    246270        return (0); 
    247271} 
     272#endif 
    248273 
    249274/* 
    250275 * Find out what ciphers /dev/crypto will let us have a session for. 
    get_cryptodev_ciphers(const int **cnids) 
    264289                return (0); 
    265290        } 
    266291        memset(&sess, 0, sizeof(sess)); 
    267         sess.key = (caddr_t)"123456781234567812345678"; 
     292        sess.key = (caddr_t)"123456789abcdefghijklmno"; 
    268293 
    269294        for (i = 0; ciphers[i].id && count < CRYPTO_ALGORITHM_MAX; i++) { 
    270295                if (ciphers[i].nid == NID_undef) 
    get_cryptodev_digests(const int **cnids) 
    303328                return (0); 
    304329        } 
    305330        memset(&sess, 0, sizeof(sess)); 
     331        sess.mackey = (caddr_t)"123456789abcdefghijklmno"; 
    306332        for (i = 0; digests[i].id && count < CRYPTO_ALGORITHM_MAX; i++) { 
    307333                if (digests[i].nid == NID_undef) 
    308334                        continue; 
    309335                sess.mac = digests[i].id; 
     336                sess.mackeylen = digests[i].keylen; 
    310337                sess.cipher = 0; 
    311338                if (ioctl(fd, CIOCGSESSION, &sess) != -1 && 
    312339                    ioctl(fd, CIOCFSESSION, &sess.ses) != -1) 
    cryptodev_usable_ciphers(const int **nid 
    351378static int 
    352379cryptodev_usable_digests(const int **nids) 
    353380{ 
     381#ifdef USE_CRYPTODEV_DIGESTS 
     382        return (get_cryptodev_digests(nids)); 
     383#else 
    354384        /* 
    355385         * XXXX just disable all digests for now, because it sucks. 
    356386         * we need a better way to decide this - i.e. I may not 
    cryptodev_usable_digests(const int **nid 
    365395         */ 
    366396        *nids = NULL; 
    367397        return (0); 
     398#endif 
    368399} 
    369400 
    370401static int 
    cryptodev_init_key(EVP_CIPHER_CTX *ctx,  
    427458{ 
    428459        struct dev_crypto_state *state = ctx->cipher_data; 
    429460        struct session_op *sess = &state->d_sess; 
    430         int cipher; 
     461        int cipher, i; 
    431462 
    432         if ((cipher = cipher_nid_to_cryptodev(ctx->cipher->nid)) == NID_undef) 
    433                 return (0); 
    434  
    435         if (ctx->cipher->iv_len > cryptodev_max_iv(cipher)) 
    436                 return (0); 
     463        for (i = 0; ciphers[i].id; i++) 
     464                if (ctx->cipher->nid == ciphers[i].nid && 
     465                    ctx->cipher->iv_len <= ciphers[i].ivmax && 
     466                    ctx->key_len == ciphers[i].keylen) { 
     467                        cipher = ciphers[i].id; 
     468                        break; 
     469                } 
    437470 
    438         if (!cryptodev_key_length_valid(cipher, ctx->key_len)) 
     471        if (!ciphers[i].id) { 
     472                state->d_fd = -1; 
    439473                return (0); 
     474        } 
    440475 
    441476        memset(sess, 0, sizeof(struct session_op)); 
    442477 
    cryptodev_cleanup(EVP_CIPHER_CTX *ctx) 
    496531 * gets called when libcrypto requests a cipher NID. 
    497532 */ 
    498533 
     534/* RC4 */ 
     535const EVP_CIPHER cryptodev_rc4 = { 
     536        NID_rc4, 
     537        1, 16, 0, 
     538        EVP_CIPH_VARIABLE_LENGTH, 
     539        cryptodev_init_key, 
     540        cryptodev_cipher, 
     541        cryptodev_cleanup, 
     542        sizeof(struct dev_crypto_state), 
     543        NULL, 
     544        NULL, 
     545        NULL 
     546}; 
     547 
    499548/* DES CBC EVP */ 
    500549const EVP_CIPHER cryptodev_des_cbc = { 
    501550        NID_des_cbc, 
    const EVP_CIPHER cryptodev_aes_cbc = { 
    563612        NULL 
    564613}; 
    565614 
     615const EVP_CIPHER cryptodev_aes_192_cbc = { 
     616        NID_aes_192_cbc, 
     617        16, 24, 16, 
     618        EVP_CIPH_CBC_MODE, 
     619        cryptodev_init_key, 
     620        cryptodev_cipher, 
     621        cryptodev_cleanup, 
     622        sizeof(struct dev_crypto_state), 
     623        EVP_CIPHER_set_asn1_iv, 
     624        EVP_CIPHER_get_asn1_iv, 
     625        NULL 
     626}; 
     627 
     628const EVP_CIPHER cryptodev_aes_256_cbc = { 
     629        NID_aes_256_cbc, 
     630        16, 32, 16, 
     631        EVP_CIPH_CBC_MODE, 
     632        cryptodev_init_key, 
     633        cryptodev_cipher, 
     634        cryptodev_cleanup, 
     635        sizeof(struct dev_crypto_state), 
     636        EVP_CIPHER_set_asn1_iv, 
     637        EVP_CIPHER_get_asn1_iv, 
     638        NULL 
     639}; 
     640 
    566641/* 
    567642 * Registered by the ENGINE when used to find out how to deal with 
    568643 * a particular NID in the ENGINE. this says what we'll do at the 
    cryptodev_engine_ciphers(ENGINE *e, cons 
    576651                return (cryptodev_usable_ciphers(nids)); 
    577652 
    578653        switch (nid) { 
     654        case NID_rc4: 
     655                *cipher = &cryptodev_rc4; 
     656                break; 
    579657        case NID_des_ede3_cbc: 
    580658                *cipher = &cryptodev_3des_cbc; 
    581659                break; 
    cryptodev_engine_ciphers(ENGINE *e, cons 
    591669        case NID_aes_128_cbc: 
    592670                *cipher = &cryptodev_aes_cbc; 
    593671                break; 
     672        case NID_aes_192_cbc: 
     673                *cipher = &cryptodev_aes_192_cbc; 
     674                break; 
     675        case NID_aes_256_cbc: 
     676                *cipher = &cryptodev_aes_256_cbc; 
     677                break; 
    594678        default: 
    595679                *cipher = NULL; 
    596680                break; 
    cryptodev_engine_ciphers(ENGINE *e, cons 
    598682        return (*cipher != NULL); 
    599683} 
    600684 
     685 
     686#ifdef USE_CRYPTODEV_DIGESTS 
     687 
     688/* convert digest type to cryptodev */ 
     689static int 
     690digest_nid_to_cryptodev(int nid) 
     691{ 
     692        int i; 
     693 
     694        for (i = 0; digests[i].id; i++) 
     695                if (digests[i].nid == nid) 
     696                        return (digests[i].id); 
     697        return (0); 
     698} 
     699 
     700 
     701static int 
     702digest_key_length(int nid) 
     703{ 
     704        int i; 
     705 
     706        for (i = 0; digests[i].id; i++) 
     707                if (digests[i].nid == nid) 
     708                        return digests[i].keylen; 
     709        return (0); 
     710} 
     711 
     712 
     713static int cryptodev_digest_init(EVP_MD_CTX *ctx) 
     714{ 
     715        struct dev_crypto_state *state = ctx->md_data; 
     716        struct session_op *sess = &state->d_sess; 
     717        int digest; 
     718 
     719        if ((digest = digest_nid_to_cryptodev(ctx->digest->type)) == NID_undef){ 
     720                printf("cryptodev_digest_init: Can't get digest \n"); 
     721                return (0); 
     722        } 
     723 
     724        memset(state, 0, sizeof(struct dev_crypto_state)); 
     725 
     726        if ((state->d_fd = get_dev_crypto()) < 0) { 
     727                printf("cryptodev_digest_init: Can't get Dev \n"); 
     728                return (0); 
     729        } 
     730 
     731        sess->mackey = state->dummy_mac_key; 
     732        sess->mackeylen = digest_key_length(ctx->digest->type); 
     733        sess->mac = digest; 
     734 
     735        if (ioctl(state->d_fd, CIOCGSESSION, sess) < 0) { 
     736                close(state->d_fd); 
     737                state->d_fd = -1; 
     738                printf("cryptodev_digest_init: Open session failed\n"); 
     739                return (0); 
     740        } 
     741 
     742        return (1); 
     743} 
     744 
     745static int cryptodev_digest_update(EVP_MD_CTX *ctx, const void *data, 
     746                size_t count) 
     747{ 
     748        struct crypt_op cryp; 
     749        struct dev_crypto_state *state = ctx->md_data; 
     750        struct session_op *sess = &state->d_sess; 
     751 
     752        if (!data || state->d_fd < 0) { 
     753                printf("cryptodev_digest_update: illegal inputs \n"); 
     754                return (0); 
     755        } 
     756 
     757        if (!count) { 
     758                return (0); 
     759        } 
     760 
     761        if (!(ctx->flags & EVP_MD_CTX_FLAG_ONESHOT)) { 
     762                /* if application doesn't support one buffer */ 
     763                state->mac_data = OPENSSL_realloc(state->mac_data, state->mac_len + count); 
     764 
     765                if (!state->mac_data) { 
     766                        printf("cryptodev_digest_update: realloc failed\n"); 
     767                        return (0); 
     768                } 
     769 
     770                memcpy(state->mac_data + state->mac_len, data, count); 
     771                state->mac_len += count; 
     772         
     773                return (1); 
     774        } 
     775 
     776        memset(&cryp, 0, sizeof(cryp)); 
     777 
     778        cryp.ses = sess->ses; 
     779        cryp.flags = 0; 
     780        cryp.len = count; 
     781        cryp.src = (caddr_t) data; 
     782        cryp.dst = NULL; 
     783        cryp.mac = state->digest_res; 
     784        if (ioctl(state->d_fd, CIOCCRYPT, &cryp) < 0) { 
     785                printf("cryptodev_digest_update: digest failed\n"); 
     786                return (0); 
     787        } 
     788        return (1); 
     789} 
     790 
     791 
     792static int cryptodev_digest_final(EVP_MD_CTX *ctx, unsigned char *md) 
     793{ 
     794        struct crypt_op cryp; 
     795        struct dev_crypto_state *state = ctx->md_data; 
     796        struct session_op *sess = &state->d_sess; 
     797 
     798        int ret = 1; 
     799 
     800        if (!md || state->d_fd < 0) { 
     801                printf("cryptodev_digest_final: illegal input\n"); 
     802                return(0); 
     803        } 
     804 
     805        if (! (ctx->flags & EVP_MD_CTX_FLAG_ONESHOT) ) { 
     806                /* if application doesn't support one buffer */ 
     807                memset(&cryp, 0, sizeof(cryp)); 
     808 
     809                cryp.ses = sess->ses; 
     810                cryp.flags = 0; 
     811                cryp.len = state->mac_len; 
     812                cryp.src = state->mac_data; 
     813                cryp.dst = NULL; 
     814                cryp.mac = md; 
     815 
     816                if (ioctl(state->d_fd, CIOCCRYPT, &cryp) < 0) { 
     817                        printf("cryptodev_digest_final: digest failed\n"); 
     818                        return (0); 
     819                } 
     820 
     821                return 1; 
     822        } 
     823 
     824        memcpy(md, state->digest_res, ctx->digest->md_size); 
     825 
     826        return (ret); 
     827} 
     828 
     829 
     830static int cryptodev_digest_cleanup(EVP_MD_CTX *ctx) 
     831{ 
     832        int ret = 1; 
     833        struct dev_crypto_state *state = ctx->md_data; 
     834        struct session_op *sess = &state->d_sess; 
     835 
     836        if (state->d_fd < 0) { 
     837                printf("cryptodev_digest_cleanup: illegal input\n"); 
     838                return (0); 
     839        } 
     840 
     841        if (state->mac_data) { 
     842                OPENSSL_free(state->mac_data); 
     843                state->mac_data = NULL; 
     844                state->mac_len = 0; 
     845        } 
     846 
     847        if (state->copy) 
     848                return 1; 
     849 
     850        if (ioctl(state->d_fd, CIOCFSESSION, &sess->ses) < 0) { 
     851                printf("cryptodev_digest_cleanup: failed to close session\n"); 
     852                ret = 0; 
     853        } else { 
     854                ret = 1; 
     855        } 
     856        close(state->d_fd);      
     857        state->d_fd = -1; 
     858 
     859        return (ret); 
     860} 
     861 
     862static int cryptodev_digest_copy(EVP_MD_CTX *to,const EVP_MD_CTX *from) 
     863{ 
     864        struct dev_crypto_state *fstate = from->md_data; 
     865        struct dev_crypto_state *dstate = to->md_data; 
     866 
     867        memcpy(dstate, fstate, sizeof(struct dev_crypto_state)); 
     868 
     869        if (fstate->mac_len != 0) { 
     870                dstate->mac_data = OPENSSL_malloc(fstate->mac_len); 
     871                memcpy(dstate->mac_data, fstate->mac_data, fstate->mac_len); 
     872        } 
     873 
     874        dstate->copy = 1; 
     875 
     876        return 1; 
     877} 
     878 
     879 
     880const EVP_MD cryptodev_sha1 = { 
     881        NID_sha1, 
     882        NID_undef,  
     883        SHA_DIGEST_LENGTH,  
     884        EVP_MD_FLAG_ONESHOT, 
     885        cryptodev_digest_init, 
     886        cryptodev_digest_update, 
     887        cryptodev_digest_final, 
     888        cryptodev_digest_copy, 
     889        cryptodev_digest_cleanup, 
     890        EVP_PKEY_NULL_method, 
     891        SHA_CBLOCK, 
     892        sizeof(struct dev_crypto_state), 
     893}; 
     894 
     895const EVP_MD cryptodev_md5 = { 
     896        NID_md5, 
     897        NID_undef,  
     898        16 /* MD5_DIGEST_LENGTH */,  
     899        EVP_MD_FLAG_ONESHOT, 
     900        cryptodev_digest_init, 
     901        cryptodev_digest_update, 
     902        cryptodev_digest_final, 
     903        cryptodev_digest_copy, 
     904        cryptodev_digest_cleanup, 
     905        EVP_PKEY_NULL_method, 
     906        64 /* MD5_CBLOCK */, 
     907        sizeof(struct dev_crypto_state), 
     908}; 
     909 
     910#endif /* USE_CRYPTODEV_DIGESTS */ 
     911 
     912 
    601913static int 
    602914cryptodev_engine_digests(ENGINE *e, const EVP_MD **digest, 
    603915    const int **nids, int nid) 
    cryptodev_engine_digests(ENGINE *e, cons 
    606918                return (cryptodev_usable_digests(nids)); 
    607919 
    608920        switch (nid) { 
     921#ifdef USE_CRYPTODEV_DIGESTS 
    609922        case NID_md5: 
    610                 *digest = NULL; /* need to make a clean md5 critter */ 
     923                *digest = &cryptodev_md5;  
    611924                break; 
     925        case NID_sha1: 
     926                *digest = &cryptodev_sha1; 
     927                break; 
    612928        default: 
     929#endif /* USE_CRYPTODEV_DIGESTS */ 
    613930                *digest = NULL; 
    614931                break; 
    615932        } 
    static int 
    625942bn2crparam(const BIGNUM *a, struct crparam *crp) 
    626943{ 
    627944        int i, j, k; 
    628         ssize_t words, bytes, bits; 
     945        ssize_t bytes, bits; 
    629946        u_char *b; 
    630947 
    631948        crp->crp_p = NULL; 
    bn2crparam(const BIGNUM *a, struct crpar 
    637954        b = malloc(bytes); 
    638955        if (b == NULL) 
    639956                return (1); 
     957        memset(b, 0, bytes); 
    640958 
    641959        crp->crp_p = b; 
    642960        crp->crp_nbits = bits; 
    zapparams(struct crypt_kop *kop) 
    681999{ 
    6821000        int i; 
    6831001 
    684         for (i = 0; i <= kop->crk_iparams + kop->crk_oparams; i++) { 
     1002        for (i = 0; i < kop->crk_iparams + kop->crk_oparams; i++) { 
    6851003                if (kop->crk_param[i].crp_p) 
    6861004                        free(kop->crk_param[i].crp_p); 
    6871005                kop->crk_param[i].crp_p = NULL; 
    err: 
    7561074} 
    7571075 
    7581076static int 
    759 cryptodev_rsa_nocrt_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa) 
     1077cryptodev_rsa_nocrt_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx) 
    7601078{ 
    7611079        int r; 
    762         BN_CTX *ctx; 
    763  
    764         ctx = BN_CTX_new(); 
     1080        ctx = BN_CTX_new(); /* not sure why we reallocate this. DM */ 
    7651081        r = cryptodev_bn_mod_exp(r0, I, rsa->d, rsa->n, ctx, NULL); 
    7661082        BN_CTX_free(ctx); 
    7671083        return (r); 
  • crypto/engine/engine.h

    a b typedef int (*dynamic_bind_engine)(ENGIN 
    703703 * values. */ 
    704704void *ENGINE_get_static_state(void); 
    705705 
    706 #if defined(__OpenBSD__) || defined(__FreeBSD__) 
     706#if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(HAVE_CRYPTODEV) 
    707707void ENGINE_setup_bsd_cryptodev(void); 
    708708#endif 
    709709 
  • 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) 
    8181        EVP_add_digest(EVP_dss()); 
    8282#endif 
    8383#endif 
    84 #ifndef OPENSSL_NO_SHA 
     84#if !defined(OPENSSL_NO_SHA) && !defined(OPENSSL_NO_SHA1) 
    8585        EVP_add_digest(EVP_sha1()); 
    8686        EVP_add_digest_alias(SN_sha1,"ssl3-sha1"); 
    8787        EVP_add_digest_alias(SN_sha1WithRSAEncryption,SN_sha1WithRSA); 
  • engines/Makefile

    a b install: 
    9696                        ( echo installing $$l; \ 
    9797                          if [ "$(PLATFORM)" != "Cygwin" ]; then \ 
    9898                                case "$(CFLAGS)" in \ 
     99                                *OPENSSL_NO_HW*)        continue;;      \ 
    99100                                *DSO_DLFCN*)    sfx="so";;      \ 
    100101                                *DSO_DL*)       sfx="sl";;      \ 
    101102                                *)              sfx="bad";;     \ 
  • util/domd

    a b if [ "$D" = "gcc" ]; then 
    2323    done 
    2424    sed -e '/^# DO NOT DELETE.*/,$d' < Makefile > Makefile.tmp 
    2525    echo '# DO NOT DELETE THIS LINE -- make depend depends on it.' >> Makefile.tmp 
    26     ${MAKEDEPEND} -D OPENSSL_DOING_MAKEDEPEND -M $args >> Makefile.tmp 
     26    ${MAKEDEPEND} -D OPENSSL_DOING_MAKEDEPEND -M $args >> Makefile.tmp && \ 
    2727    ${PERL} $TOP/util/clean-depend.pl < Makefile.tmp > Makefile.new 
     28      RC=$? 
    2829    rm -f Makefile.tmp 
    2930else 
    30     ${MAKEDEPEND} -D OPENSSL_DOING_MAKEDEPEND $@ 
     31    ${MAKEDEPEND} -D OPENSSL_DOING_MAKEDEPEND $@ && \ 
    3132    ${PERL} $TOP/util/clean-depend.pl < Makefile > Makefile.new 
     33      RC=$? 
    3234fi 
    3335mv Makefile.new Makefile 
    3436# unfake the presence of Kerberos 
    3537rm $TOP/krb5.h 
     38 
     39exit $RC 
Note: See TracBrowser for help on using the repository browser.