crypto/armcap.c

   1 /*
   2  * Copyright 2011-2023 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 <openssl/crypto.h>
  14 #ifdef __APPLE__
  15 #include <sys/sysctl.h>
  16 #else
  17 #include <setjmp.h>
  18 #include <signal.h>
  19 #endif
  20 #include "internal/cryptlib.h"
  21 #ifdef _WIN32
  22 #include <windows.h>
  23 #else
  24 #include <unistd.h>
  25 #endif
  26 #include "arm_arch.h"
  27
  28 #ifdef __aarch64__
  29 unsigned int OPENSSL_armcap_P = 0;
  30 #endif
  31 unsigned int OPENSSL_arm_midr = 0;
  32 unsigned int OPENSSL_armv8_rsa_neonized = 0;
  33
  34 #ifdef _WIN32
  35 void OPENSSL_cpuid_setup(void)
  36 {
  37     OPENSSL_armcap_P |= ARMV7_NEON;
  38     OPENSSL_armv8_rsa_neonized = 1;
  39     if (IsProcessorFeaturePresent(PF_ARM_V8_CRYPTO_INSTRUCTIONS_AVAILABLE)) {
  40         // These are all covered by one call in Windows
  41         OPENSSL_armcap_P |= ARMV8_AES;
  42         OPENSSL_armcap_P |= ARMV8_PMULL;
  43         OPENSSL_armcap_P |= ARMV8_SHA1;
  44         OPENSSL_armcap_P |= ARMV8_SHA256;
  45     }
  46 }
  47
  48 uint32_t OPENSSL_rdtsc(void)
  49 {
  50     return 0;
  51 }
  52 #elif __ARM_MAX_ARCH__ < 7
  53 void OPENSSL_cpuid_setup(void)
  54 {
  55 }
  56
  57 uint32_t OPENSSL_rdtsc(void)
  58 {
  59     return 0;
  60 }
  61 #else /* !_WIN32 && __ARM_MAX_ARCH__ >= 7 */
  62
  63  /* 3 ways of handling things here: __APPLE__,  getauxval() or SIGILL detect */
  64
  65  /* First determine if getauxval() is available (OSSL_IMPLEMENT_GETAUXVAL) */
  66
  67 # if defined(__GNUC__) && __GNUC__>=2
  68 void OPENSSL_cpuid_setup(void) __attribute__ ((constructor));
  69 # endif
  70
  71 # if defined(__GLIBC__) && defined(__GLIBC_PREREQ)
  72 #  if __GLIBC_PREREQ(2, 16)
  73 #   include <sys/auxv.h>
  74 #   define OSSL_IMPLEMENT_GETAUXVAL
  75 #  endif
  76 # elif defined(__ANDROID_API__)
  77 /* see https://developer.android.google.cn/ndk/guides/cpu-features */
  78 #  if __ANDROID_API__ >= 18
  79 #   include <sys/auxv.h>
  80 #   define OSSL_IMPLEMENT_GETAUXVAL
  81 #  endif
  82 # endif
  83 # if defined(__FreeBSD__)
  84 #  include <sys/param.h>
  85 #  if __FreeBSD_version >= 1200000
  86 #   include <sys/auxv.h>
  87 #   define OSSL_IMPLEMENT_GETAUXVAL
  88
  89 static unsigned long getauxval(unsigned long key)
  90 {
  91   unsigned long val = 0ul;
  92
  93   if (elf_aux_info((int)key, &val, sizeof(val)) != 0)
  94     return 0ul;
  95
  96   return val;
  97 }
  98 #  endif
  99 # endif
 100
 101 /*
 102  * Android: according to https://developer.android.com/ndk/guides/cpu-features,
 103  * getauxval is supported starting with API level 18
 104  */
 105 # if defined(__ANDROID__) && defined(__ANDROID_API__) && __ANDROID_API__ >= 18
 106 #  include <sys/auxv.h>
 107 #  define OSSL_IMPLEMENT_GETAUXVAL
 108 # endif
 109
 110 /*
 111  * ARM puts the feature bits for Crypto Extensions in AT_HWCAP2, whereas
 112  * AArch64 used AT_HWCAP.
 113  */
 114 # ifndef AT_HWCAP
 115 #  define AT_HWCAP               16
 116 # endif
 117 # ifndef AT_HWCAP2
 118 #  define AT_HWCAP2              26
 119 # endif
 120 # if defined(__arm__) || defined (__arm)
 121 #  define OSSL_HWCAP                  AT_HWCAP
 122 #  define OSSL_HWCAP_NEON             (1 << 12)
 123
 124 #  define OSSL_HWCAP_CE               AT_HWCAP2
 125 #  define OSSL_HWCAP_CE_AES           (1 << 0)
 126 #  define OSSL_HWCAP_CE_PMULL         (1 << 1)
 127 #  define OSSL_HWCAP_CE_SHA1          (1 << 2)
 128 #  define OSSL_HWCAP_CE_SHA256        (1 << 3)
 129 # elif defined(__aarch64__)
 130 #  define OSSL_HWCAP                  AT_HWCAP
 131 #  define OSSL_HWCAP_NEON             (1 << 1)
 132
 133 #  define OSSL_HWCAP_CE               AT_HWCAP
 134 #  define OSSL_HWCAP_CE_AES           (1 << 3)
 135 #  define OSSL_HWCAP_CE_PMULL         (1 << 4)
 136 #  define OSSL_HWCAP_CE_SHA1          (1 << 5)
 137 #  define OSSL_HWCAP_CE_SHA256        (1 << 6)
 138 #  define OSSL_HWCAP_CPUID            (1 << 11)
 139 #  define OSSL_HWCAP_SHA3             (1 << 17)
 140 #  define OSSL_HWCAP_CE_SM3           (1 << 18)
 141 #  define OSSL_HWCAP_CE_SM4           (1 << 19)
 142 #  define OSSL_HWCAP_CE_SHA512        (1 << 21)
 143 #  define OSSL_HWCAP_SVE              (1 << 22)
 144                                       /* AT_HWCAP2 */
 145 #  define OSSL_HWCAP2                 26
 146 #  define OSSL_HWCAP2_SVE2            (1 << 1)
 147 #  define OSSL_HWCAP2_RNG             (1 << 16)
 148 # endif
 149
 150 uint32_t _armv7_tick(void);
 151
 152 uint32_t OPENSSL_rdtsc(void)
 153 {
 154     if (OPENSSL_armcap_P & ARMV7_TICK)
 155         return _armv7_tick();
 156     else
 157         return 0;
 158 }
 159
 160 # ifdef __aarch64__
 161 size_t OPENSSL_rndr_asm(unsigned char *buf, size_t len);
 162 size_t OPENSSL_rndrrs_asm(unsigned char *buf, size_t len);
 163
 164 size_t OPENSSL_rndr_bytes(unsigned char *buf, size_t len);
 165 size_t OPENSSL_rndrrs_bytes(unsigned char *buf, size_t len);
 166
 167 static size_t OPENSSL_rndr_wrapper(size_t (*func)(unsigned char *, size_t), unsigned char *buf, size_t len)
 168 {
 169     size_t buffer_size = 0;
 170     int i;
 171
 172     for (i = 0; i < 8; i++) {
 173         buffer_size = func(buf, len);
 174         if (buffer_size == len)
 175             break;
 176         usleep(5000);  /* 5000 microseconds (5 milliseconds) */
 177     }
 178     return buffer_size;
 179 }
 180
 181 size_t OPENSSL_rndr_bytes(unsigned char *buf, size_t len)
 182 {
 183     return OPENSSL_rndr_wrapper(OPENSSL_rndr_asm, buf, len);
 184 }
 185
 186 size_t OPENSSL_rndrrs_bytes(unsigned char *buf, size_t len)
 187 {
 188     return OPENSSL_rndr_wrapper(OPENSSL_rndrrs_asm, buf, len);
 189 }
 190 # endif
 191
 192 # if !defined(__APPLE__) && !defined(OSSL_IMPLEMENT_GETAUXVAL)
 193 static sigset_t all_masked;
 194
 195 static sigjmp_buf ill_jmp;
 196 static void ill_handler(int sig)
 197 {
 198     siglongjmp(ill_jmp, sig);
 199 }
 200
 201 /*
 202  * Following subroutines could have been inlined, but not all
 203  * ARM compilers support inline assembler, and we'd then have to
 204  * worry about the compiler optimising out the detection code...
 205  */
 206 void _armv7_neon_probe(void);
 207 void _armv8_aes_probe(void);
 208 void _armv8_sha1_probe(void);
 209 void _armv8_sha256_probe(void);
 210 void _armv8_pmull_probe(void);
 211 #  ifdef __aarch64__
 212 void _armv8_sm3_probe(void);
 213 void _armv8_sm4_probe(void);
 214 void _armv8_sha512_probe(void);
 215 void _armv8_eor3_probe(void);
 216 void _armv8_sve_probe(void);
 217 void _armv8_sve2_probe(void);
 218 void _armv8_rng_probe(void);
 219 #  endif
 220 # endif /* !__APPLE__ && !OSSL_IMPLEMENT_GETAUXVAL */
 221
 222 /* We only call _armv8_cpuid_probe() if (OPENSSL_armcap_P & ARMV8_CPUID) != 0 */
 223 unsigned int _armv8_cpuid_probe(void);
 224
 225 # if defined(__APPLE__)
 226 /*
 227  * Checks the specified integer sysctl, returning `value` if it's 1, otherwise returning 0.
 228  */
 229 static unsigned int sysctl_query(const char *name, unsigned int value)
 230 {
 231     unsigned int sys_value = 0;
 232     size_t len = sizeof(sys_value);
 233
 234     return (sysctlbyname(name, &sys_value, &len, NULL, 0) == 0 && sys_value == 1) ? value : 0;
 235 }
 236 # elif !defined(OSSL_IMPLEMENT_GETAUXVAL)
 237 /*
 238  * Calls a provided probe function, which may SIGILL. If it doesn't, return `value`, otherwise return 0.
 239  */
 240 static unsigned int arm_probe_for(void (*probe)(void), volatile unsigned int value)
 241 {
 242     if (sigsetjmp(ill_jmp, 1) == 0) {
 243         probe();
 244         return value;
 245     } else {
 246         /* The probe function gave us SIGILL */
 247         return 0;
 248     }
 249 }
 250 # endif
 251
 252 void OPENSSL_cpuid_setup(void)
 253 {
 254     const char *e;
 255 # if !defined(__APPLE__) && !defined(OSSL_IMPLEMENT_GETAUXVAL)
 256     struct sigaction ill_oact, ill_act;
 257     sigset_t oset;
 258 # endif
 259     static int trigger = 0;
 260
 261     if (trigger)
 262         return;
 263     trigger = 1;
 264
 265     OPENSSL_armcap_P = 0;
 266
 267     if ((e = getenv("OPENSSL_armcap"))) {
 268         OPENSSL_armcap_P = (unsigned int)strtoul(e, NULL, 0);
 269         return;
 270     }
 271
 272 # if defined(__APPLE__)
 273 #  if !defined(__aarch64__)
 274     /*
 275      * Capability probing by catching SIGILL appears to be problematic
 276      * on iOS. But since Apple universe is "monocultural", it's actually
 277      * possible to simply set pre-defined processor capability mask.
 278      */
 279     if (1) {
 280         OPENSSL_armcap_P = ARMV7_NEON;
 281         return;
 282     }
 283 #  else
 284     {
 285         /*
 286          * From
 287          * https://github.com/llvm/llvm-project/blob/412237dcd07e5a2afbb1767858262a5f037149a3/llvm/lib/Target/AArch64/AArch64.td#L719
 288          * all of these have been available on 64-bit Apple Silicon from the
 289          * beginning (the A7).
 290          */
 291         OPENSSL_armcap_P |= ARMV7_NEON | ARMV8_PMULL | ARMV8_AES | ARMV8_SHA1 | ARMV8_SHA256;
 292
 293         /* More recent extensions are indicated by sysctls */
 294         OPENSSL_armcap_P |= sysctl_query("hw.optional.armv8_2_sha512", ARMV8_SHA512);
 295         OPENSSL_armcap_P |= sysctl_query("hw.optional.armv8_2_sha3", ARMV8_SHA3);
 296
 297         if (OPENSSL_armcap_P & ARMV8_SHA3) {
 298             char uarch[64];
 299
 300             size_t len = sizeof(uarch);
 301             if ((sysctlbyname("machdep.cpu.brand_string", uarch, &len, NULL, 0) == 0) &&
 302                ((strncmp(uarch, "Apple M1", 8) == 0) ||
 303                 (strncmp(uarch, "Apple M2", 8) == 0))) {
 304                 OPENSSL_armcap_P |= ARMV8_UNROLL8_EOR3;
 305             }
 306         }
 307     }
 308 #  endif       /* __aarch64__ */
 309
 310 # elif defined(OSSL_IMPLEMENT_GETAUXVAL)
 311
 312     if (getauxval(OSSL_HWCAP) & OSSL_HWCAP_NEON) {
 313         unsigned long hwcap = getauxval(OSSL_HWCAP_CE);
 314
 315         OPENSSL_armcap_P |= ARMV7_NEON;
 316
 317         if (hwcap & OSSL_HWCAP_CE_AES)
 318             OPENSSL_armcap_P |= ARMV8_AES;
 319
 320         if (hwcap & OSSL_HWCAP_CE_PMULL)
 321             OPENSSL_armcap_P |= ARMV8_PMULL;
 322
 323         if (hwcap & OSSL_HWCAP_CE_SHA1)
 324             OPENSSL_armcap_P |= ARMV8_SHA1;
 325
 326         if (hwcap & OSSL_HWCAP_CE_SHA256)
 327             OPENSSL_armcap_P |= ARMV8_SHA256;
 328
 329 #  ifdef __aarch64__
 330         if (hwcap & OSSL_HWCAP_CE_SM4)
 331             OPENSSL_armcap_P |= ARMV8_SM4;
 332
 333         if (hwcap & OSSL_HWCAP_CE_SHA512)
 334             OPENSSL_armcap_P |= ARMV8_SHA512;
 335
 336         if (hwcap & OSSL_HWCAP_CPUID)
 337             OPENSSL_armcap_P |= ARMV8_CPUID;
 338
 339         if (hwcap & OSSL_HWCAP_CE_SM3)
 340             OPENSSL_armcap_P |= ARMV8_SM3;
 341         if (hwcap & OSSL_HWCAP_SHA3)
 342             OPENSSL_armcap_P |= ARMV8_SHA3;
 343 #  endif
 344     }
 345 #  ifdef __aarch64__
 346         if (getauxval(OSSL_HWCAP) & OSSL_HWCAP_SVE)
 347             OPENSSL_armcap_P |= ARMV8_SVE;
 348
 349         if (getauxval(OSSL_HWCAP2) & OSSL_HWCAP2_SVE2)
 350             OPENSSL_armcap_P |= ARMV8_SVE2;
 351
 352         if (getauxval(OSSL_HWCAP2) & OSSL_HWCAP2_RNG)
 353             OPENSSL_armcap_P |= ARMV8_RNG;
 354 #  endif
 355
 356 # else /* !__APPLE__ && !OSSL_IMPLEMENT_GETAUXVAL */
 357
 358     /* If all else fails, do brute force SIGILL-based feature detection */
 359
 360     sigfillset(&all_masked);
 361     sigdelset(&all_masked, SIGILL);
 362     sigdelset(&all_masked, SIGTRAP);
 363     sigdelset(&all_masked, SIGFPE);
 364     sigdelset(&all_masked, SIGBUS);
 365     sigdelset(&all_masked, SIGSEGV);
 366
 367     memset(&ill_act, 0, sizeof(ill_act));
 368     ill_act.sa_handler = ill_handler;
 369     ill_act.sa_mask = all_masked;
 370
 371     sigprocmask(SIG_SETMASK, &ill_act.sa_mask, &oset);
 372     sigaction(SIGILL, &ill_act, &ill_oact);
 373
 374     OPENSSL_armcap_P |= arm_probe_for(_armv7_neon_probe, ARMV7_NEON);
 375
 376     if (OPENSSL_armcap_P & ARMV7_NEON) {
 377
 378         OPENSSL_armcap_P |= arm_probe_for(_armv8_pmull_probe, ARMV8_PMULL | ARMV8_AES);
 379         if (!(OPENSSL_armcap_P & ARMV8_AES)) {
 380             OPENSSL_armcap_P |= arm_probe_for(_armv8_aes_probe, ARMV8_AES);
 381         }
 382
 383         OPENSSL_armcap_P |= arm_probe_for(_armv8_sha1_probe, ARMV8_SHA1);
 384         OPENSSL_armcap_P |= arm_probe_for(_armv8_sha256_probe, ARMV8_SHA256);
 385
 386 #  if defined(__aarch64__)
 387         OPENSSL_armcap_P |= arm_probe_for(_armv8_sm3_probe, ARMV8_SM3);
 388         OPENSSL_armcap_P |= arm_probe_for(_armv8_sm4_probe, ARMV8_SM4);
 389         OPENSSL_armcap_P |= arm_probe_for(_armv8_sha512_probe, ARMV8_SHA512);
 390         OPENSSL_armcap_P |= arm_probe_for(_armv8_eor3_probe, ARMV8_SHA3);
 391 #  endif
 392     }
 393 #  ifdef __aarch64__
 394     OPENSSL_armcap_P |= arm_probe_for(_armv8_sve_probe, ARMV8_SVE);
 395     OPENSSL_armcap_P |= arm_probe_for(_armv8_sve2_probe, ARMV8_SVE2);
 396     OPENSSL_armcap_P |= arm_probe_for(_armv8_rng_probe, ARMV8_RNG);
 397 #  endif
 398
 399     /*
 400      * Probing for ARMV7_TICK is known to produce unreliable results,
 401      * so we only use the feature when the user explicitly enables it
 402      * with OPENSSL_armcap.
 403      */
 404
 405     sigaction(SIGILL, &ill_oact, NULL);
 406     sigprocmask(SIG_SETMASK, &oset, NULL);
 407
 408 # endif /* __APPLE__, OSSL_IMPLEMENT_GETAUXVAL */
 409
 410 # ifdef __aarch64__
 411     if (OPENSSL_armcap_P & ARMV8_CPUID)
 412         OPENSSL_arm_midr = _armv8_cpuid_probe();
 413
 414     if ((MIDR_IS_CPU_MODEL(OPENSSL_arm_midr, ARM_CPU_IMP_ARM, ARM_CPU_PART_CORTEX_A72) ||
 415          MIDR_IS_CPU_MODEL(OPENSSL_arm_midr, ARM_CPU_IMP_ARM, ARM_CPU_PART_N1)) &&
 416         (OPENSSL_armcap_P & ARMV7_NEON)) {
 417             OPENSSL_armv8_rsa_neonized = 1;
 418     }
 419     if ((MIDR_IS_CPU_MODEL(OPENSSL_arm_midr, ARM_CPU_IMP_ARM, ARM_CPU_PART_V1) ||
 420          MIDR_IS_CPU_MODEL(OPENSSL_arm_midr, ARM_CPU_IMP_ARM, ARM_CPU_PART_N2) ||
 421          MIDR_IS_CPU_MODEL(OPENSSL_arm_midr, ARM_CPU_IMP_ARM, ARM_CPU_PART_V2)) &&
 422         (OPENSSL_armcap_P & ARMV8_SHA3))
 423         OPENSSL_armcap_P |= ARMV8_UNROLL8_EOR3;
 424 # endif
 425 }
 426 #endif /* _WIN32, __ARM_MAX_ARCH__ >= 7 */