Add scrypt OID from draft-josefsson-scrypt-kdf-03
[openssl.git] / crypto / ppccap.c
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4 #include <setjmp.h>
5 #include <signal.h>
6 #include <unistd.h>
7 #if defined(__linux) || defined(_AIX)
8 # include <sys/utsname.h>
9 #endif
10 #include <crypto.h>
11 #include <openssl/bn.h>
12
13 #include "ppc_arch.h"
14
15 unsigned int OPENSSL_ppccap_P = 0;
16
17 static sigset_t all_masked;
18
19 #ifdef OPENSSL_BN_ASM_MONT
20 int bn_mul_mont(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp,
21                 const BN_ULONG *np, const BN_ULONG *n0, int num)
22 {
23     int bn_mul_mont_fpu64(BN_ULONG *rp, const BN_ULONG *ap,
24                           const BN_ULONG *bp, const BN_ULONG *np,
25                           const BN_ULONG *n0, int num);
26     int bn_mul_mont_int(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp,
27                         const BN_ULONG *np, const BN_ULONG *n0, int num);
28
29     if (sizeof(size_t) == 4) {
30 # if 1 || (defined(__APPLE__) && defined(__MACH__))
31         if (num >= 8 && (num & 3) == 0 && (OPENSSL_ppccap_P & PPC_FPU64))
32             return bn_mul_mont_fpu64(rp, ap, bp, np, n0, num);
33 # else
34         /*
35          * boundary of 32 was experimentally determined on Linux 2.6.22,
36          * might have to be adjusted on AIX...
37          */
38         if (num >= 32 && (num & 3) == 0 && (OPENSSL_ppccap_P & PPC_FPU64)) {
39             sigset_t oset;
40             int ret;
41
42             sigprocmask(SIG_SETMASK, &all_masked, &oset);
43             ret = bn_mul_mont_fpu64(rp, ap, bp, np, n0, num);
44             sigprocmask(SIG_SETMASK, &oset, NULL);
45
46             return ret;
47         }
48 # endif
49     } else if ((OPENSSL_ppccap_P & PPC_FPU64))
50         /*
51          * this is a "must" on POWER6, but run-time detection is not
52          * implemented yet...
53          */
54         return bn_mul_mont_fpu64(rp, ap, bp, np, n0, num);
55
56     return bn_mul_mont_int(rp, ap, bp, np, n0, num);
57 }
58 #endif
59
60 void sha256_block_p8(void *ctx, const void *inp, size_t len);
61 void sha256_block_ppc(void *ctx, const void *inp, size_t len);
62 void sha256_block_data_order(void *ctx, const void *inp, size_t len)
63 {
64     OPENSSL_ppccap_P & PPC_CRYPTO207 ? sha256_block_p8(ctx, inp, len) :
65         sha256_block_ppc(ctx, inp, len);
66 }
67
68 void sha512_block_p8(void *ctx, const void *inp, size_t len);
69 void sha512_block_ppc(void *ctx, const void *inp, size_t len);
70 void sha512_block_data_order(void *ctx, const void *inp, size_t len)
71 {
72     OPENSSL_ppccap_P & PPC_CRYPTO207 ? sha512_block_p8(ctx, inp, len) :
73         sha512_block_ppc(ctx, inp, len);
74 }
75
76 static sigjmp_buf ill_jmp;
77 static void ill_handler(int sig)
78 {
79     siglongjmp(ill_jmp, sig);
80 }
81
82 void OPENSSL_ppc64_probe(void);
83 void OPENSSL_altivec_probe(void);
84 void OPENSSL_crypto207_probe(void);
85
86 void OPENSSL_cpuid_setup(void)
87 {
88     char *e;
89     struct sigaction ill_oact, ill_act;
90     sigset_t oset;
91     static int trigger = 0;
92
93     if (trigger)
94         return;
95     trigger = 1;
96
97     sigfillset(&all_masked);
98     sigdelset(&all_masked, SIGILL);
99     sigdelset(&all_masked, SIGTRAP);
100 #ifdef SIGEMT
101     sigdelset(&all_masked, SIGEMT);
102 #endif
103     sigdelset(&all_masked, SIGFPE);
104     sigdelset(&all_masked, SIGBUS);
105     sigdelset(&all_masked, SIGSEGV);
106
107     if ((e = getenv("OPENSSL_ppccap"))) {
108         OPENSSL_ppccap_P = strtoul(e, NULL, 0);
109         return;
110     }
111
112     OPENSSL_ppccap_P = 0;
113
114 #if defined(_AIX)
115     if (sizeof(size_t) == 4) {
116         struct utsname uts;
117 # if defined(_SC_AIX_KERNEL_BITMODE)
118         if (sysconf(_SC_AIX_KERNEL_BITMODE) != 64)
119             return;
120 # endif
121         if (uname(&uts) != 0 || atoi(uts.version) < 6)
122             return;
123     }
124 #endif
125
126     memset(&ill_act, 0, sizeof(ill_act));
127     ill_act.sa_handler = ill_handler;
128     ill_act.sa_mask = all_masked;
129
130     sigprocmask(SIG_SETMASK, &ill_act.sa_mask, &oset);
131     sigaction(SIGILL, &ill_act, &ill_oact);
132
133     if (sizeof(size_t) == 4) {
134 #ifdef __linux
135         struct utsname uts;
136         if (uname(&uts) == 0 && strcmp(uts.machine, "ppc64") == 0)
137 #endif
138             if (sigsetjmp(ill_jmp, 1) == 0) {
139                 OPENSSL_ppc64_probe();
140                 OPENSSL_ppccap_P |= PPC_FPU64;
141             }
142     } else {
143         /*
144          * Wanted code detecting POWER6 CPU and setting PPC_FPU64
145          */
146     }
147
148     if (sigsetjmp(ill_jmp, 1) == 0) {
149         OPENSSL_altivec_probe();
150         OPENSSL_ppccap_P |= PPC_ALTIVEC;
151         if (sigsetjmp(ill_jmp, 1) == 0) {
152             OPENSSL_crypto207_probe();
153             OPENSSL_ppccap_P |= PPC_CRYPTO207;
154         }
155     }
156
157     sigaction(SIGILL, &ill_oact, NULL);
158     sigprocmask(SIG_SETMASK, &oset, NULL);
159 }