Coverage Report

Created: 2024-11-21 07:03

/src/boringssl/crypto/crypto.c
Line
Count
Source (jump to first uncovered line)
1
/* Copyright (c) 2014, Google Inc.
2
 *
3
 * Permission to use, copy, modify, and/or distribute this software for any
4
 * purpose with or without fee is hereby granted, provided that the above
5
 * copyright notice and this permission notice appear in all copies.
6
 *
7
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
8
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
9
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
10
 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
11
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
12
 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
13
 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
14
15
#include <openssl/crypto.h>
16
17
#include <assert.h>
18
#include <stdio.h>
19
20
#include "bcm_support.h"
21
#include "fipsmodule/rand/internal.h"
22
#include "internal.h"
23
24
25
static_assert(sizeof(ossl_ssize_t) == sizeof(size_t),
26
              "ossl_ssize_t should be the same size as size_t");
27
28
29
// Our assembly does not use the GOT to reference symbols, which means
30
// references to visible symbols will often require a TEXTREL. This is
31
// undesirable, so all assembly-referenced symbols should be hidden. CPU
32
// capabilities are the only such symbols defined in C. Explicitly hide them,
33
// rather than rely on being built with -fvisibility=hidden.
34
#if defined(OPENSSL_WINDOWS)
35
#define HIDDEN
36
#else
37
#define HIDDEN __attribute__((visibility("hidden")))
38
#endif
39
40
41
// The capability variables are defined in this file in order to work around a
42
// linker bug. When linking with a .a, if no symbols in a .o are referenced
43
// then the .o is discarded, even if it has constructor functions.
44
//
45
// This still means that any binaries that don't include some functionality
46
// that tests the capability values will still skip the constructor but, so
47
// far, the init constructor function only sets the capability variables.
48
49
#if defined(BORINGSSL_DISPATCH_TEST)
50
// This value must be explicitly initialised to zero in order to work around a
51
// bug in libtool or the linker on OS X.
52
//
53
// If not initialised then it becomes a "common symbol". When put into an
54
// archive, linking on OS X will fail to resolve common symbols. By
55
// initialising it to zero, it becomes a "data symbol", which isn't so
56
// affected.
57
HIDDEN uint8_t BORINGSSL_function_hit[7] = {0};
58
#endif
59
60
#if defined(OPENSSL_X86) || defined(OPENSSL_X86_64)
61
62
// This value must be explicitly initialized to zero. See similar comment above.
63
HIDDEN uint32_t OPENSSL_ia32cap_P[4] = {0};
64
65
47.8k
uint32_t OPENSSL_get_ia32cap(int idx) {
66
47.8k
  OPENSSL_init_cpuid();
67
47.8k
  return OPENSSL_ia32cap_P[idx];
68
47.8k
}
69
70
#elif defined(OPENSSL_ARM) || defined(OPENSSL_AARCH64)
71
72
#include <openssl/arm_arch.h>
73
74
#if defined(OPENSSL_STATIC_ARMCAP)
75
76
// See ARM ACLE for the definitions of these macros. Note |__ARM_FEATURE_AES|
77
// covers both AES and PMULL and |__ARM_FEATURE_SHA2| covers SHA-1 and SHA-256.
78
// https://developer.arm.com/architectures/system-architectures/software-standards/acle
79
// https://github.com/ARM-software/acle/issues/152
80
//
81
// TODO(davidben): Do we still need |OPENSSL_STATIC_ARMCAP_*| or are the
82
// standard flags and -march sufficient?
83
HIDDEN uint32_t OPENSSL_armcap_P =
84
#if defined(OPENSSL_STATIC_ARMCAP_NEON) || defined(__ARM_NEON)
85
    ARMV7_NEON |
86
#endif
87
#if defined(OPENSSL_STATIC_ARMCAP_AES) || defined(__ARM_FEATURE_AES)
88
    ARMV8_AES |
89
#endif
90
#if defined(OPENSSL_STATIC_ARMCAP_PMULL) || defined(__ARM_FEATURE_AES)
91
    ARMV8_PMULL |
92
#endif
93
#if defined(OPENSSL_STATIC_ARMCAP_SHA1) || defined(__ARM_FEATURE_SHA2)
94
    ARMV8_SHA1 |
95
#endif
96
#if defined(OPENSSL_STATIC_ARMCAP_SHA256) || defined(__ARM_FEATURE_SHA2)
97
    ARMV8_SHA256 |
98
#endif
99
#if defined(__ARM_FEATURE_SHA512)
100
    ARMV8_SHA512 |
101
#endif
102
    0;
103
104
#else
105
HIDDEN uint32_t OPENSSL_armcap_P = 0;
106
107
uint32_t *OPENSSL_get_armcap_pointer_for_test(void) {
108
  OPENSSL_init_cpuid();
109
  return &OPENSSL_armcap_P;
110
}
111
#endif
112
113
uint32_t OPENSSL_get_armcap(void) {
114
  OPENSSL_init_cpuid();
115
  return OPENSSL_armcap_P;
116
}
117
118
#endif
119
120
#if defined(NEED_CPUID)
121
static CRYPTO_once_t once = CRYPTO_ONCE_INIT;
122
47.8k
void OPENSSL_init_cpuid(void) { CRYPTO_once(&once, OPENSSL_cpuid_setup); }
123
#endif
124
125
0
void CRYPTO_library_init(void) {}
126
127
0
int CRYPTO_is_confidential_build(void) {
128
#if defined(BORINGSSL_CONFIDENTIAL)
129
  return 1;
130
#else
131
0
  return 0;
132
0
#endif
133
0
}
134
135
0
void CRYPTO_pre_sandbox_init(void) {
136
  // Read from /proc/cpuinfo if needed.
137
0
  OPENSSL_init_cpuid();
138
  // Open /dev/urandom if needed.
139
0
  CRYPTO_init_sysrand();
140
  // Set up MADV_WIPEONFORK state if needed.
141
0
  CRYPTO_get_fork_generation();
142
0
}
143
144
0
const char *SSLeay_version(int which) { return OpenSSL_version(which); }
145
146
0
const char *OpenSSL_version(int which) {
147
0
  switch (which) {
148
0
    case OPENSSL_VERSION:
149
0
      return "BoringSSL";
150
0
    case OPENSSL_CFLAGS:
151
0
      return "compiler: n/a";
152
0
    case OPENSSL_BUILT_ON:
153
0
      return "built on: n/a";
154
0
    case OPENSSL_PLATFORM:
155
0
      return "platform: n/a";
156
0
    case OPENSSL_DIR:
157
0
      return "OPENSSLDIR: n/a";
158
0
    default:
159
0
      return "not available";
160
0
  }
161
0
}
162
163
0
unsigned long SSLeay(void) { return OPENSSL_VERSION_NUMBER; }
164
165
0
unsigned long OpenSSL_version_num(void) { return OPENSSL_VERSION_NUMBER; }
166
167
0
int CRYPTO_malloc_init(void) { return 1; }
168
169
0
int OPENSSL_malloc_init(void) { return 1; }
170
171
0
void ENGINE_load_builtin_engines(void) {}
172
173
0
int ENGINE_register_all_complete(void) { return 1; }
174
175
0
void OPENSSL_load_builtin_modules(void) {}
176
177
4
int OPENSSL_init_crypto(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings) {
178
4
  return 1;
179
4
}
180
181
void OPENSSL_cleanup(void) {}
182
183
0
FILE *CRYPTO_get_stderr(void) { return stderr; }