mirror of
https://github.com/ossrs/srs.git
synced 2025-03-09 15:49:59 +00:00
AppleM1: Update openssl to v1.1.1l
This commit is contained in:
winlin
parent
1fe12b8e8c
commit
b787656eea
990 changed files with 13406 additions and 18710 deletions
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved.
|
||||
* Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
|
||||
*
|
||||
* Licensed under the OpenSSL license (the "License"). You may not use
|
||||
* this file except in compliance with the License. You can obtain a copy
|
||||
|
|
@ -14,21 +14,29 @@
|
|||
#include <stdio.h>
|
||||
#include "internal/cryptlib.h"
|
||||
#include <openssl/rand.h>
|
||||
#include "rand_lcl.h"
|
||||
#include "internal/rand_int.h"
|
||||
#include <openssl/crypto.h>
|
||||
#include "rand_local.h"
|
||||
#include "crypto/rand.h"
|
||||
#include <stdio.h>
|
||||
#include "internal/dso.h"
|
||||
#if defined(__linux)
|
||||
#ifdef __linux
|
||||
# include <sys/syscall.h>
|
||||
# ifdef DEVRANDOM_WAIT
|
||||
# include <sys/shm.h>
|
||||
# include <sys/utsname.h>
|
||||
# endif
|
||||
#endif
|
||||
#if defined(__FreeBSD__)
|
||||
#if (defined(__FreeBSD__) || defined(__NetBSD__)) && !defined(OPENSSL_SYS_UEFI)
|
||||
# include <sys/types.h>
|
||||
# include <sys/sysctl.h>
|
||||
# include <sys/param.h>
|
||||
#endif
|
||||
#if defined(__OpenBSD__) || defined(__NetBSD__)
|
||||
#if defined(__OpenBSD__)
|
||||
# include <sys/param.h>
|
||||
#endif
|
||||
#if defined(__APPLE__)
|
||||
# include <CommonCrypto/CommonRandom.h>
|
||||
#endif
|
||||
|
||||
#if defined(OPENSSL_SYS_UNIX) || defined(__DJGPP__)
|
||||
# include <sys/types.h>
|
||||
|
|
@ -75,7 +83,8 @@ static uint64_t get_timer_bits(void);
|
|||
# define OSSL_POSIX_TIMER_OKAY
|
||||
# endif
|
||||
# endif
|
||||
#endif /* defined(OPENSSL_SYS_UNIX) || defined(__DJGPP__) */
|
||||
#endif /* (defined(OPENSSL_SYS_UNIX) && !defined(OPENSSL_SYS_VXWORKS))
|
||||
|| defined(__DJGPP__) */
|
||||
|
||||
#if defined(OPENSSL_RAND_SEED_NONE)
|
||||
/* none means none. this simplifies the following logic */
|
||||
|
|
@ -241,10 +250,12 @@ static ssize_t sysctl_random(char *buf, size_t buflen)
|
|||
* when the sysctl returns long and we want to request something not a
|
||||
* multiple of longs, which should never be the case.
|
||||
*/
|
||||
#if defined(__FreeBSD__)
|
||||
if (!ossl_assert(buflen % sizeof(long) == 0)) {
|
||||
errno = EINVAL;
|
||||
return -1;
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
* On NetBSD before 4.0 KERN_ARND was an alias for KERN_URND, and only
|
||||
|
|
@ -262,7 +273,7 @@ static ssize_t sysctl_random(char *buf, size_t buflen)
|
|||
mib[1] = KERN_ARND;
|
||||
|
||||
do {
|
||||
len = buflen;
|
||||
len = buflen > 256 ? 256 : buflen;
|
||||
if (sysctl(mib, 2, buf, &len, NULL, 0) == -1)
|
||||
return done > 0 ? done : -1;
|
||||
done += len;
|
||||
|
|
@ -275,6 +286,63 @@ static ssize_t sysctl_random(char *buf, size_t buflen)
|
|||
# endif
|
||||
|
||||
# if defined(OPENSSL_RAND_SEED_GETRANDOM)
|
||||
|
||||
# if defined(__linux) && !defined(__NR_getrandom)
|
||||
# if defined(__arm__)
|
||||
# define __NR_getrandom (__NR_SYSCALL_BASE+384)
|
||||
# elif defined(__i386__)
|
||||
# define __NR_getrandom 355
|
||||
# elif defined(__x86_64__)
|
||||
# if defined(__ILP32__)
|
||||
# define __NR_getrandom (__X32_SYSCALL_BIT + 318)
|
||||
# else
|
||||
# define __NR_getrandom 318
|
||||
# endif
|
||||
# elif defined(__xtensa__)
|
||||
# define __NR_getrandom 338
|
||||
# elif defined(__s390__) || defined(__s390x__)
|
||||
# define __NR_getrandom 349
|
||||
# elif defined(__bfin__)
|
||||
# define __NR_getrandom 389
|
||||
# elif defined(__powerpc__)
|
||||
# define __NR_getrandom 359
|
||||
# elif defined(__mips__) || defined(__mips64)
|
||||
# if _MIPS_SIM == _MIPS_SIM_ABI32
|
||||
# define __NR_getrandom (__NR_Linux + 353)
|
||||
# elif _MIPS_SIM == _MIPS_SIM_ABI64
|
||||
# define __NR_getrandom (__NR_Linux + 313)
|
||||
# elif _MIPS_SIM == _MIPS_SIM_NABI32
|
||||
# define __NR_getrandom (__NR_Linux + 317)
|
||||
# endif
|
||||
# elif defined(__hppa__)
|
||||
# define __NR_getrandom (__NR_Linux + 339)
|
||||
# elif defined(__sparc__)
|
||||
# define __NR_getrandom 347
|
||||
# elif defined(__ia64__)
|
||||
# define __NR_getrandom 1339
|
||||
# elif defined(__alpha__)
|
||||
# define __NR_getrandom 511
|
||||
# elif defined(__sh__)
|
||||
# if defined(__SH5__)
|
||||
# define __NR_getrandom 373
|
||||
# else
|
||||
# define __NR_getrandom 384
|
||||
# endif
|
||||
# elif defined(__avr32__)
|
||||
# define __NR_getrandom 317
|
||||
# elif defined(__microblaze__)
|
||||
# define __NR_getrandom 385
|
||||
# elif defined(__m68k__)
|
||||
# define __NR_getrandom 352
|
||||
# elif defined(__cris__)
|
||||
# define __NR_getrandom 356
|
||||
# elif defined(__aarch64__)
|
||||
# define __NR_getrandom 278
|
||||
# else /* generic */
|
||||
# define __NR_getrandom 278
|
||||
# endif
|
||||
# endif
|
||||
|
||||
/*
|
||||
* syscall_random(): Try to get random data using a system call
|
||||
* returns the number of bytes returned in buf, or < 0 on error.
|
||||
|
|
@ -300,12 +368,24 @@ static ssize_t syscall_random(void *buf, size_t buflen)
|
|||
* - OpenBSD since 5.6
|
||||
* - Linux since 3.17 with glibc 2.25
|
||||
* - FreeBSD since 12.0 (1200061)
|
||||
*
|
||||
* Note: Sometimes getentropy() can be provided but not implemented
|
||||
* internally. So we need to check errno for ENOSYS
|
||||
*/
|
||||
# if defined(__GNUC__) && __GNUC__>=2 && defined(__ELF__) && !defined(__hpux)
|
||||
extern int getentropy(void *buffer, size_t length) __attribute__((weak));
|
||||
|
||||
if (getentropy != NULL)
|
||||
return getentropy(buf, buflen) == 0 ? (ssize_t)buflen : -1;
|
||||
if (getentropy != NULL) {
|
||||
if (getentropy(buf, buflen) == 0)
|
||||
return (ssize_t)buflen;
|
||||
if (errno != ENOSYS)
|
||||
return -1;
|
||||
}
|
||||
# elif defined(__APPLE__)
|
||||
if (CCRandomGenerateBytes(buf, buflen) == kCCSuccess)
|
||||
return (ssize_t)buflen;
|
||||
|
||||
return -1;
|
||||
# else
|
||||
union {
|
||||
void *p;
|
||||
|
|
@ -324,8 +404,8 @@ static ssize_t syscall_random(void *buf, size_t buflen)
|
|||
# endif
|
||||
|
||||
/* Linux supports this since version 3.17 */
|
||||
# if defined(__linux) && defined(SYS_getrandom)
|
||||
return syscall(SYS_getrandom, buf, buflen, 0);
|
||||
# if defined(__linux) && defined(__NR_getrandom)
|
||||
return syscall(__NR_getrandom, buf, buflen, 0);
|
||||
# elif (defined(__FreeBSD__) || defined(__NetBSD__)) && defined(KERN_ARND)
|
||||
return sysctl_random(buf, buflen);
|
||||
# else
|
||||
|
|
@ -346,6 +426,92 @@ static struct random_device {
|
|||
} random_devices[OSSL_NELEM(random_device_paths)];
|
||||
static int keep_random_devices_open = 1;
|
||||
|
||||
# if defined(__linux) && defined(DEVRANDOM_WAIT) \
|
||||
&& defined(OPENSSL_RAND_SEED_GETRANDOM)
|
||||
static void *shm_addr;
|
||||
|
||||
static void cleanup_shm(void)
|
||||
{
|
||||
shmdt(shm_addr);
|
||||
}
|
||||
|
||||
/*
|
||||
* Ensure that the system randomness source has been adequately seeded.
|
||||
* This is done by having the first start of libcrypto, wait until the device
|
||||
* /dev/random becomes able to supply a byte of entropy. Subsequent starts
|
||||
* of the library and later reseedings do not need to do this.
|
||||
*/
|
||||
static int wait_random_seeded(void)
|
||||
{
|
||||
static int seeded = OPENSSL_RAND_SEED_DEVRANDOM_SHM_ID < 0;
|
||||
static const int kernel_version[] = { DEVRANDOM_SAFE_KERNEL };
|
||||
int kernel[2];
|
||||
int shm_id, fd, r;
|
||||
char c, *p;
|
||||
struct utsname un;
|
||||
fd_set fds;
|
||||
|
||||
if (!seeded) {
|
||||
/* See if anything has created the global seeded indication */
|
||||
if ((shm_id = shmget(OPENSSL_RAND_SEED_DEVRANDOM_SHM_ID, 1, 0)) == -1) {
|
||||
/*
|
||||
* Check the kernel's version and fail if it is too recent.
|
||||
*
|
||||
* Linux kernels from 4.8 onwards do not guarantee that
|
||||
* /dev/urandom is properly seeded when /dev/random becomes
|
||||
* readable. However, such kernels support the getentropy(2)
|
||||
* system call and this should always succeed which renders
|
||||
* this alternative but essentially identical source moot.
|
||||
*/
|
||||
if (uname(&un) == 0) {
|
||||
kernel[0] = atoi(un.release);
|
||||
p = strchr(un.release, '.');
|
||||
kernel[1] = p == NULL ? 0 : atoi(p + 1);
|
||||
if (kernel[0] > kernel_version[0]
|
||||
|| (kernel[0] == kernel_version[0]
|
||||
&& kernel[1] >= kernel_version[1])) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
/* Open /dev/random and wait for it to be readable */
|
||||
if ((fd = open(DEVRANDOM_WAIT, O_RDONLY)) != -1) {
|
||||
if (DEVRANDM_WAIT_USE_SELECT && fd < FD_SETSIZE) {
|
||||
FD_ZERO(&fds);
|
||||
FD_SET(fd, &fds);
|
||||
while ((r = select(fd + 1, &fds, NULL, NULL, NULL)) < 0
|
||||
&& errno == EINTR);
|
||||
} else {
|
||||
while ((r = read(fd, &c, 1)) < 0 && errno == EINTR);
|
||||
}
|
||||
close(fd);
|
||||
if (r == 1) {
|
||||
seeded = 1;
|
||||
/* Create the shared memory indicator */
|
||||
shm_id = shmget(OPENSSL_RAND_SEED_DEVRANDOM_SHM_ID, 1,
|
||||
IPC_CREAT | S_IRUSR | S_IRGRP | S_IROTH);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (shm_id != -1) {
|
||||
seeded = 1;
|
||||
/*
|
||||
* Map the shared memory to prevent its premature destruction.
|
||||
* If this call fails, it isn't a big problem.
|
||||
*/
|
||||
shm_addr = shmat(shm_id, NULL, SHM_RDONLY);
|
||||
if (shm_addr != (void *)-1)
|
||||
OPENSSL_atexit(&cleanup_shm);
|
||||
}
|
||||
}
|
||||
return seeded;
|
||||
}
|
||||
# else /* defined __linux && DEVRANDOM_WAIT && OPENSSL_RAND_SEED_GETRANDOM */
|
||||
static int wait_random_seeded(void)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
# endif
|
||||
|
||||
/*
|
||||
* Verify that the file descriptor associated with the random source is
|
||||
* still valid. The rationale for doing this is the fact that it is not
|
||||
|
|
@ -472,12 +638,12 @@ size_t rand_pool_acquire_entropy(RAND_POOL *pool)
|
|||
# if defined(OPENSSL_RAND_SEED_NONE)
|
||||
return rand_pool_entropy_available(pool);
|
||||
# else
|
||||
size_t bytes_needed;
|
||||
size_t entropy_available = 0;
|
||||
unsigned char *buffer;
|
||||
size_t entropy_available;
|
||||
|
||||
# if defined(OPENSSL_RAND_SEED_GETRANDOM)
|
||||
{
|
||||
size_t bytes_needed;
|
||||
unsigned char *buffer;
|
||||
ssize_t bytes;
|
||||
/* Maximum allowed number of consecutive unsuccessful attempts */
|
||||
int attempts = 3;
|
||||
|
|
@ -507,13 +673,16 @@ size_t rand_pool_acquire_entropy(RAND_POOL *pool)
|
|||
# endif
|
||||
|
||||
# if defined(OPENSSL_RAND_SEED_DEVRANDOM)
|
||||
bytes_needed = rand_pool_bytes_needed(pool, 1 /*entropy_factor*/);
|
||||
{
|
||||
if (wait_random_seeded()) {
|
||||
size_t bytes_needed;
|
||||
unsigned char *buffer;
|
||||
size_t i;
|
||||
|
||||
for (i = 0; bytes_needed > 0 && i < OSSL_NELEM(random_device_paths); i++) {
|
||||
bytes_needed = rand_pool_bytes_needed(pool, 1 /*entropy_factor*/);
|
||||
for (i = 0; bytes_needed > 0 && i < OSSL_NELEM(random_device_paths);
|
||||
i++) {
|
||||
ssize_t bytes = 0;
|
||||
/* Maximum allowed number of consecutive unsuccessful attempts */
|
||||
/* Maximum number of consecutive unsuccessful attempts */
|
||||
int attempts = 3;
|
||||
const int fd = get_random_device(i);
|
||||
|
||||
|
|
@ -527,7 +696,7 @@ size_t rand_pool_acquire_entropy(RAND_POOL *pool)
|
|||
if (bytes > 0) {
|
||||
rand_pool_add_end(pool, bytes, 8 * bytes);
|
||||
bytes_needed -= bytes;
|
||||
attempts = 3; /* reset counter after successful attempt */
|
||||
attempts = 3; /* reset counter on successful attempt */
|
||||
} else if (bytes < 0 && errno != EINTR) {
|
||||
break;
|
||||
}
|
||||
|
|
@ -535,7 +704,7 @@ size_t rand_pool_acquire_entropy(RAND_POOL *pool)
|
|||
if (bytes < 0 || !keep_random_devices_open)
|
||||
close_random_device(i);
|
||||
|
||||
bytes_needed = rand_pool_bytes_needed(pool, 1 /*entropy_factor*/);
|
||||
bytes_needed = rand_pool_bytes_needed(pool, 1);
|
||||
}
|
||||
entropy_available = rand_pool_entropy_available(pool);
|
||||
if (entropy_available > 0)
|
||||
|
|
@ -556,26 +725,29 @@ size_t rand_pool_acquire_entropy(RAND_POOL *pool)
|
|||
# endif
|
||||
|
||||
# if defined(OPENSSL_RAND_SEED_EGD)
|
||||
bytes_needed = rand_pool_bytes_needed(pool, 1 /*entropy_factor*/);
|
||||
if (bytes_needed > 0) {
|
||||
{
|
||||
static const char *paths[] = { DEVRANDOM_EGD, NULL };
|
||||
size_t bytes_needed;
|
||||
unsigned char *buffer;
|
||||
int i;
|
||||
|
||||
for (i = 0; paths[i] != NULL; i++) {
|
||||
buffer = rand_pool_add_begin(pool, bytes_needed);
|
||||
if (buffer != NULL) {
|
||||
size_t bytes = 0;
|
||||
int num = RAND_query_egd_bytes(paths[i],
|
||||
buffer, (int)bytes_needed);
|
||||
if (num == (int)bytes_needed)
|
||||
bytes = bytes_needed;
|
||||
bytes_needed = rand_pool_bytes_needed(pool, 1 /*entropy_factor*/);
|
||||
for (i = 0; bytes_needed > 0 && paths[i] != NULL; i++) {
|
||||
size_t bytes = 0;
|
||||
int num;
|
||||
|
||||
rand_pool_add_end(pool, bytes, 8 * bytes);
|
||||
entropy_available = rand_pool_entropy_available(pool);
|
||||
}
|
||||
if (entropy_available > 0)
|
||||
return entropy_available;
|
||||
buffer = rand_pool_add_begin(pool, bytes_needed);
|
||||
num = RAND_query_egd_bytes(paths[i],
|
||||
buffer, (int)bytes_needed);
|
||||
if (num == (int)bytes_needed)
|
||||
bytes = bytes_needed;
|
||||
|
||||
rand_pool_add_end(pool, bytes, 8 * bytes);
|
||||
bytes_needed = rand_pool_bytes_needed(pool, 1);
|
||||
}
|
||||
entropy_available = rand_pool_entropy_available(pool);
|
||||
if (entropy_available > 0)
|
||||
return entropy_available;
|
||||
}
|
||||
# endif
|
||||
|
||||
|
|
@ -609,15 +781,18 @@ int rand_pool_add_nonce_data(RAND_POOL *pool)
|
|||
int rand_pool_add_additional_data(RAND_POOL *pool)
|
||||
{
|
||||
struct {
|
||||
int fork_id;
|
||||
CRYPTO_THREAD_ID tid;
|
||||
uint64_t time;
|
||||
} data = { 0 };
|
||||
|
||||
/*
|
||||
* Add some noise from the thread id and a high resolution timer.
|
||||
* The fork_id adds some extra fork-safety.
|
||||
* The thread id adds a little randomness if the drbg is accessed
|
||||
* concurrently (which is the case for the <master> drbg).
|
||||
*/
|
||||
data.fork_id = openssl_get_fork_id();
|
||||
data.tid = CRYPTO_THREAD_get_current_id();
|
||||
data.time = get_timer_bits();
|
||||
|
||||
|
|
@ -704,4 +879,5 @@ static uint64_t get_timer_bits(void)
|
|||
# endif
|
||||
return time(NULL);
|
||||
}
|
||||
#endif /* defined(OPENSSL_SYS_UNIX) || defined(__DJGPP__) */
|
||||
#endif /* (defined(OPENSSL_SYS_UNIX) && !defined(OPENSSL_SYS_VXWORKS))
|
||||
|| defined(__DJGPP__) */
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue