crypto/armcap.c

   1 /*
   2  * Copyright 2011-2022 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <setjmp.h>
  14 #include <signal.h>
  15 #include <openssl/crypto.h>
  16 #ifdef __APPLE__
  17 #include <sys/sysctl.h>
  18 #endif
  19 #include "internal/cryptlib.h"
  20 #ifndef _WIN32
  21 #include <unistd.h>
  22 #else
  23 #include <windows.h>
  24 #endif
  25 #include "arm_arch.h"
  26
  27 unsigned int OPENSSL_armcap_P = 0;
  28 unsigned int OPENSSL_arm_midr = 0;
  29 unsigned int OPENSSL_armv8_rsa_neonized = 0;
  30
  31 #ifdef _WIN32
  32 void OPENSSL_cpuid_setup(void)
  33 {
  34     OPENSSL_armcap_P |= ARMV7_NEON;
  35     OPENSSL_armv8_rsa_neonized = 1;
  36     if (IsProcessorFeaturePresent(PF_ARM_V8_CRYPTO_INSTRUCTIONS_AVAILABLE)) {
  37         // These are all covered by one call in Windows
  38         OPENSSL_armcap_P |= ARMV8_AES;
  39         OPENSSL_armcap_P |= ARMV8_PMULL;
  40         OPENSSL_armcap_P |= ARMV8_SHA1;
  41         OPENSSL_armcap_P |= ARMV8_SHA256;
  42     }
  43 }
  44
  45 uint32_t OPENSSL_rdtsc(void)
  46 {
  47     return 0;
  48 }
  49 #elif __ARM_MAX_ARCH__<7
  50 void OPENSSL_cpuid_setup(void)
  51 {
  52 }
  53
  54 uint32_t OPENSSL_rdtsc(void)
  55 {
  56     return 0;
  57 }
  58 #else
  59 static sigset_t all_masked;
  60
  61 static sigjmp_buf ill_jmp;
  62 static void ill_handler(int sig)
  63 {
  64     siglongjmp(ill_jmp, sig);
  65 }
  66
  67 /*
  68  * Following subroutines could have been inlined, but it's not all
  69  * ARM compilers support inline assembler...
  70  */
  71 void _armv7_neon_probe(void);
  72 void _armv8_aes_probe(void);
  73 void _armv8_sha1_probe(void);
  74 void _armv8_sha256_probe(void);
  75 void _armv8_pmull_probe(void);
  76 # ifdef __aarch64__
  77 void _armv8_sm3_probe(void);
  78 void _armv8_sm4_probe(void);
  79 void _armv8_eor3_probe(void);
  80 void _armv8_sha512_probe(void);
  81 unsigned int _armv8_cpuid_probe(void);
  82 void _armv8_sve_probe(void);
  83 void _armv8_sve2_probe(void);
  84 void _armv8_rng_probe(void);
  85
  86 size_t OPENSSL_rndr_asm(unsigned char *buf, size_t len);
  87 size_t OPENSSL_rndrrs_asm(unsigned char *buf, size_t len);
  88
  89 size_t OPENSSL_rndr_bytes(unsigned char *buf, size_t len);
  90 size_t OPENSSL_rndrrs_bytes(unsigned char *buf, size_t len);
  91
  92 static size_t OPENSSL_rndr_wrapper(size_t (*func)(unsigned char *, size_t), unsigned char *buf, size_t len)
  93 {
  94     size_t buffer_size = 0;
  95     int i;
  96
  97     for (i = 0; i < 8; i++) {
  98         buffer_size = func(buf, len);
  99         if (buffer_size == len)
 100             break;
 101         usleep(5000);  /* 5000 microseconds (5 milliseconds) */
 102     }
 103     return buffer_size;
 104 }
 105
 106 size_t OPENSSL_rndr_bytes(unsigned char *buf, size_t len)
 107 {
 108     return OPENSSL_rndr_wrapper(OPENSSL_rndr_asm, buf, len);
 109 }
 110
 111 size_t OPENSSL_rndrrs_bytes(unsigned char *buf, size_t len)
 112 {
 113     return OPENSSL_rndr_wrapper(OPENSSL_rndrrs_asm, buf, len);
 114 }
 115 # endif
 116 uint32_t _armv7_tick(void);
 117
 118 uint32_t OPENSSL_rdtsc(void)
 119 {
 120     if (OPENSSL_armcap_P & ARMV7_TICK)
 121         return _armv7_tick();
 122     else
 123         return 0;
 124 }
 125
 126 # if defined(__GNUC__) && __GNUC__>=2
 127 void OPENSSL_cpuid_setup(void) __attribute__ ((constructor));
 128 # endif
 129
 130 # if defined(__GLIBC__) && defined(__GLIBC_PREREQ)
 131 #  if __GLIBC_PREREQ(2, 16)
 132 #   include <sys/auxv.h>
 133 #   define OSSL_IMPLEMENT_GETAUXVAL
 134 #  endif
 135 # elif defined(__ANDROID_API__)
 136 /* see https://developer.android.google.cn/ndk/guides/cpu-features */
 137 #  if __ANDROID_API__ >= 18
 138 #   include <sys/auxv.h>
 139 #   define OSSL_IMPLEMENT_GETAUXVAL
 140 #  endif
 141 # endif
 142 # if defined(__FreeBSD__)
 143 #  include <sys/param.h>
 144 #  if __FreeBSD_version >= 1200000
 145 #   include <sys/auxv.h>
 146 #   define OSSL_IMPLEMENT_GETAUXVAL
 147
 148 static unsigned long getauxval(unsigned long key)
 149 {
 150   unsigned long val = 0ul;
 151
 152   if (elf_aux_info((int)key, &val, sizeof(val)) != 0)
 153     return 0ul;
 154
 155   return val;
 156 }
 157 #  endif
 158 # endif
 159
 160 /*
 161  * Android: according to https://developer.android.com/ndk/guides/cpu-features,
 162  * getauxval is supported starting with API level 18
 163  */
 164 #  if defined(__ANDROID__) && defined(__ANDROID_API__) && __ANDROID_API__ >= 18
 165 #   include <sys/auxv.h>
 166 #   define OSSL_IMPLEMENT_GETAUXVAL
 167 #  endif
 168
 169 /*
 170  * ARM puts the feature bits for Crypto Extensions in AT_HWCAP2, whereas
 171  * AArch64 used AT_HWCAP.
 172  */
 173 # ifndef AT_HWCAP
 174 #  define AT_HWCAP               16
 175 # endif
 176 # ifndef AT_HWCAP2
 177 #  define AT_HWCAP2              26
 178 # endif
 179 # if defined(__arm__) || defined (__arm)
 180 #  define HWCAP                  AT_HWCAP
 181 #  define HWCAP_NEON             (1 << 12)
 182
 183 #  define HWCAP_CE               AT_HWCAP2
 184 #  define HWCAP_CE_AES           (1 << 0)
 185 #  define HWCAP_CE_PMULL         (1 << 1)
 186 #  define HWCAP_CE_SHA1          (1 << 2)
 187 #  define HWCAP_CE_SHA256        (1 << 3)
 188 # elif defined(__aarch64__)
 189 #  define HWCAP                  AT_HWCAP
 190 #  define HWCAP_NEON             (1 << 1)
 191
 192 #  define HWCAP_CE               HWCAP
 193 #  define HWCAP_CE_AES           (1 << 3)
 194 #  define HWCAP_CE_PMULL         (1 << 4)
 195 #  define HWCAP_CE_SHA1          (1 << 5)
 196 #  define HWCAP_CE_SHA256        (1 << 6)
 197 #  define HWCAP_CPUID            (1 << 11)
 198 #  define HWCAP_SHA3             (1 << 17)
 199 #  define HWCAP_CE_SM3           (1 << 18)
 200 #  define HWCAP_CE_SM4           (1 << 19)
 201 #  define HWCAP_CE_SHA512        (1 << 21)
 202 #  define HWCAP_SVE              (1 << 22)
 203                                   /* AT_HWCAP2 */
 204 #  define HWCAP2                 26
 205 #  define HWCAP2_SVE2            (1 << 1)
 206 #  define HWCAP2_RNG             (1 << 16)
 207 # endif
 208
 209 void OPENSSL_cpuid_setup(void)
 210 {
 211     const char *e;
 212     struct sigaction ill_oact, ill_act;
 213     sigset_t oset;
 214     static int trigger = 0;
 215
 216     if (trigger)
 217         return;
 218     trigger = 1;
 219
 220     OPENSSL_armcap_P = 0;
 221
 222     if ((e = getenv("OPENSSL_armcap"))) {
 223         OPENSSL_armcap_P = (unsigned int)strtoul(e, NULL, 0);
 224         return;
 225     }
 226
 227 # if defined(__APPLE__)
 228 #   if !defined(__aarch64__)
 229     /*
 230      * Capability probing by catching SIGILL appears to be problematic
 231      * on iOS. But since Apple universe is "monocultural", it's actually
 232      * possible to simply set pre-defined processor capability mask.
 233      */
 234     if (1) {
 235         OPENSSL_armcap_P = ARMV7_NEON;
 236         return;
 237     }
 238     /*
 239      * One could do same even for __aarch64__ iOS builds. It's not done
 240      * exclusively for reasons of keeping code unified across platforms.
 241      * Unified code works because it never triggers SIGILL on Apple
 242      * devices...
 243      */
 244 #   else
 245     {
 246         unsigned int feature;
 247         size_t len = sizeof(feature);
 248         char uarch[64];
 249
 250         if (sysctlbyname("hw.optional.armv8_2_sha512", &feature, &len, NULL, 0) == 0 && feature == 1)
 251             OPENSSL_armcap_P |= ARMV8_SHA512;
 252         feature = 0;
 253         if (sysctlbyname("hw.optional.armv8_2_sha3", &feature, &len, NULL, 0) == 0 && feature == 1) {
 254             OPENSSL_armcap_P |= ARMV8_SHA3;
 255             len = sizeof(uarch);
 256             if ((sysctlbyname("machdep.cpu.brand_string", uarch, &len, NULL, 0) == 0) &&
 257                 (strncmp(uarch, "Apple M1", 8) == 0))
 258                 OPENSSL_armcap_P |= ARMV8_UNROLL8_EOR3;
 259         }
 260     }
 261 #   endif
 262 # endif
 263
 264 # ifdef OSSL_IMPLEMENT_GETAUXVAL
 265     if (getauxval(HWCAP) & HWCAP_NEON) {
 266         unsigned long hwcap = getauxval(HWCAP_CE);
 267
 268         OPENSSL_armcap_P |= ARMV7_NEON;
 269
 270         if (hwcap & HWCAP_CE_AES)
 271             OPENSSL_armcap_P |= ARMV8_AES;
 272
 273         if (hwcap & HWCAP_CE_PMULL)
 274             OPENSSL_armcap_P |= ARMV8_PMULL;
 275
 276         if (hwcap & HWCAP_CE_SHA1)
 277             OPENSSL_armcap_P |= ARMV8_SHA1;
 278
 279         if (hwcap & HWCAP_CE_SHA256)
 280             OPENSSL_armcap_P |= ARMV8_SHA256;
 281
 282 #  ifdef __aarch64__
 283         if (hwcap & HWCAP_CE_SM4)
 284             OPENSSL_armcap_P |= ARMV8_SM4;
 285
 286         if (hwcap & HWCAP_CE_SHA512)
 287             OPENSSL_armcap_P |= ARMV8_SHA512;
 288
 289         if (hwcap & HWCAP_CPUID)
 290             OPENSSL_armcap_P |= ARMV8_CPUID;
 291
 292         if (hwcap & HWCAP_CE_SM3)
 293             OPENSSL_armcap_P |= ARMV8_SM3;
 294         if (hwcap & HWCAP_SHA3)
 295             OPENSSL_armcap_P |= ARMV8_SHA3;
 296 #  endif
 297     }
 298 #  ifdef __aarch64__
 299         if (getauxval(HWCAP) & HWCAP_SVE)
 300             OPENSSL_armcap_P |= ARMV8_SVE;
 301
 302         if (getauxval(HWCAP2) & HWCAP2_SVE2)
 303             OPENSSL_armcap_P |= ARMV8_SVE2;
 304
 305         if (getauxval(HWCAP2) & HWCAP2_RNG)
 306             OPENSSL_armcap_P |= ARMV8_RNG;
 307 #  endif
 308 # endif
 309
 310     sigfillset(&all_masked);
 311     sigdelset(&all_masked, SIGILL);
 312     sigdelset(&all_masked, SIGTRAP);
 313     sigdelset(&all_masked, SIGFPE);
 314     sigdelset(&all_masked, SIGBUS);
 315     sigdelset(&all_masked, SIGSEGV);
 316
 317     memset(&ill_act, 0, sizeof(ill_act));
 318     ill_act.sa_handler = ill_handler;
 319     ill_act.sa_mask = all_masked;
 320
 321     sigprocmask(SIG_SETMASK, &ill_act.sa_mask, &oset);
 322     sigaction(SIGILL, &ill_act, &ill_oact);
 323
 324     /* If we used getauxval, we already have all the values */
 325 # ifndef OSSL_IMPLEMENT_GETAUXVAL
 326     if (sigsetjmp(ill_jmp, 1) == 0) {
 327         _armv7_neon_probe();
 328         OPENSSL_armcap_P |= ARMV7_NEON;
 329         if (sigsetjmp(ill_jmp, 1) == 0) {
 330             _armv8_pmull_probe();
 331             OPENSSL_armcap_P |= ARMV8_PMULL | ARMV8_AES;
 332         } else if (sigsetjmp(ill_jmp, 1) == 0) {
 333             _armv8_aes_probe();
 334             OPENSSL_armcap_P |= ARMV8_AES;
 335         }
 336         if (sigsetjmp(ill_jmp, 1) == 0) {
 337             _armv8_sha1_probe();
 338             OPENSSL_armcap_P |= ARMV8_SHA1;
 339         }
 340         if (sigsetjmp(ill_jmp, 1) == 0) {
 341             _armv8_sha256_probe();
 342             OPENSSL_armcap_P |= ARMV8_SHA256;
 343         }
 344 #  if defined(__aarch64__) && !defined(__APPLE__)
 345         if (sigsetjmp(ill_jmp, 1) == 0) {
 346             _armv8_sm4_probe();
 347             OPENSSL_armcap_P |= ARMV8_SM4;
 348         }
 349
 350         if (sigsetjmp(ill_jmp, 1) == 0) {
 351             _armv8_sha512_probe();
 352             OPENSSL_armcap_P |= ARMV8_SHA512;
 353         }
 354
 355         if (sigsetjmp(ill_jmp, 1) == 0) {
 356             _armv8_sm3_probe();
 357             OPENSSL_armcap_P |= ARMV8_SM3;
 358         }
 359         if (sigsetjmp(ill_jmp, 1) == 0) {
 360             _armv8_eor3_probe();
 361             OPENSSL_armcap_P |= ARMV8_SHA3;
 362         }
 363 #  endif
 364     }
 365 #  ifdef __aarch64__
 366     if (sigsetjmp(ill_jmp, 1) == 0) {
 367         _armv8_sve_probe();
 368         OPENSSL_armcap_P |= ARMV8_SVE;
 369     }
 370
 371     if (sigsetjmp(ill_jmp, 1) == 0) {
 372         _armv8_sve2_probe();
 373         OPENSSL_armcap_P |= ARMV8_SVE2;
 374     }
 375
 376     if (sigsetjmp(ill_jmp, 1) == 0) {
 377         _armv8_rng_probe();
 378         OPENSSL_armcap_P |= ARMV8_RNG;
 379     }
 380 #  endif
 381 # endif
 382
 383     /*
 384      * Probing for ARMV7_TICK is known to produce unreliable results,
 385      * so we will only use the feature when the user explicitly enables
 386      * it with OPENSSL_armcap.
 387      */
 388
 389     sigaction(SIGILL, &ill_oact, NULL);
 390     sigprocmask(SIG_SETMASK, &oset, NULL);
 391
 392 # ifdef __aarch64__
 393     if (OPENSSL_armcap_P & ARMV8_CPUID)
 394         OPENSSL_arm_midr = _armv8_cpuid_probe();
 395
 396     if ((MIDR_IS_CPU_MODEL(OPENSSL_arm_midr, ARM_CPU_IMP_ARM, ARM_CPU_PART_CORTEX_A72) ||
 397          MIDR_IS_CPU_MODEL(OPENSSL_arm_midr, ARM_CPU_IMP_ARM, ARM_CPU_PART_N1)) &&
 398         (OPENSSL_armcap_P & ARMV7_NEON)) {
 399             OPENSSL_armv8_rsa_neonized = 1;
 400     }
 401     if ((MIDR_IS_CPU_MODEL(OPENSSL_arm_midr, ARM_CPU_IMP_ARM, ARM_CPU_PART_V1) ||
 402          MIDR_IS_CPU_MODEL(OPENSSL_arm_midr, ARM_CPU_IMP_ARM, ARM_CPU_PART_N2)) &&
 403         (OPENSSL_armcap_P & ARMV8_SHA3))
 404         OPENSSL_armcap_P |= ARMV8_UNROLL8_EOR3;
 405 # endif
 406 }
 407 #endif