path: root/contrib/python/cryptography/_cffi_src/openssl/src/osrandom_engine.c

/* osurandom engine 
 * 
 * Windows         CryptGenRandom() 
 * macOS >= 10.12  getentropy() 
 * OpenBSD 5.6+    getentropy() 
 * other BSD       getentropy() if SYS_getentropy is defined 
 * Linux 3.17+     getrandom() with fallback to /dev/urandom 
 * other           /dev/urandom with cached fd 
 * 
 * The /dev/urandom, getrandom and getentropy code is derived from Python's 
 * Python/random.c, written by Antoine Pitrou and Victor Stinner. 
 * 
 * Copyright 2001-2016 Python Software Foundation; All Rights Reserved. 
 */ 
 
#ifdef __linux__ 
#include <poll.h> 
#endif 
 
#if CRYPTOGRAPHY_NEEDS_OSRANDOM_ENGINE 
/* OpenSSL has ENGINE support and is older than 1.1.1d (the first version that 
 * properly implements fork safety in its RNG) so build the engine. */ 
static const char *Cryptography_osrandom_engine_id = "osrandom"; 
 
/**************************************************************************** 
 * Windows 
 */ 
#if CRYPTOGRAPHY_OSRANDOM_ENGINE == CRYPTOGRAPHY_OSRANDOM_ENGINE_CRYPTGENRANDOM 
static const char *Cryptography_osrandom_engine_name = "osrandom_engine CryptGenRandom()"; 
static HCRYPTPROV hCryptProv = 0; 
 
static int osrandom_init(ENGINE *e) { 
    if (hCryptProv != 0) { 
        return 1; 
    } 
    if (CryptAcquireContext(&hCryptProv, NULL, NULL, 
                            PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) { 
        return 1; 
    } else { 
        ERR_Cryptography_OSRandom_error( 
            CRYPTOGRAPHY_OSRANDOM_F_INIT, 
            CRYPTOGRAPHY_OSRANDOM_R_CRYPTACQUIRECONTEXT, 
            __FILE__, __LINE__ 
        ); 
        return 0; 
    } 
} 
 
static int osrandom_rand_bytes(unsigned char *buffer, int size) { 
    if (hCryptProv == 0) { 
        return 0; 
    } 
 
    if (!CryptGenRandom(hCryptProv, (DWORD)size, buffer)) { 
        ERR_Cryptography_OSRandom_error( 
            CRYPTOGRAPHY_OSRANDOM_F_RAND_BYTES, 
            CRYPTOGRAPHY_OSRANDOM_R_CRYPTGENRANDOM, 
            __FILE__, __LINE__ 
        ); 
        return 0; 
    } 
    return 1; 
} 
 
static int osrandom_finish(ENGINE *e) { 
    if (CryptReleaseContext(hCryptProv, 0)) { 
        hCryptProv = 0; 
        return 1; 
    } else { 
        ERR_Cryptography_OSRandom_error( 
            CRYPTOGRAPHY_OSRANDOM_F_FINISH, 
            CRYPTOGRAPHY_OSRANDOM_R_CRYPTRELEASECONTEXT, 
            __FILE__, __LINE__ 
        ); 
        return 0; 
    } 
} 
 
static int osrandom_rand_status(void) { 
    return hCryptProv != 0; 
} 
 
static const char *osurandom_get_implementation(void) { 
    return "CryptGenRandom"; 
} 
 
#endif /* CRYPTOGRAPHY_OSRANDOM_ENGINE_CRYPTGENRANDOM */ 
 
/**************************************************************************** 
 * /dev/urandom helpers for all non-BSD Unix platforms 
 */ 
#ifdef CRYPTOGRAPHY_OSRANDOM_NEEDS_DEV_URANDOM 
 
static struct { 
    int fd; 
    dev_t st_dev; 
    ino_t st_ino; 
} urandom_cache = { -1 }; 
 
static int open_cloexec(const char *path) { 
    int open_flags = O_RDONLY; 
#ifdef O_CLOEXEC 
    open_flags |= O_CLOEXEC; 
#endif 
 
    int fd = open(path, open_flags); 
    if (fd == -1) { 
        return -1; 
    } 
 
#ifndef O_CLOEXEC 
    int flags = fcntl(fd, F_GETFD); 
    if (flags == -1) { 
        return -1; 
    } 
    if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == -1) { 
        return -1; 
    } 
#endif 
    return fd; 
} 
 
#ifdef __linux__ 
/* On Linux, we open("/dev/random") and use poll() to wait until it's readable 
 * before we read from /dev/urandom, this ensures that we don't read from 
 * /dev/urandom before the kernel CSPRNG is initialized. This isn't necessary on 
 * other platforms because they don't have the same _bug_ as Linux does with 
 * /dev/urandom and early boot. */ 
static int wait_on_devrandom(void) { 
    struct pollfd pfd = {}; 
    int ret = 0; 
    int random_fd = open_cloexec("/dev/random"); 
    if (random_fd < 0) { 
        return -1; 
    } 
    pfd.fd = random_fd; 
    pfd.events = POLLIN; 
    pfd.revents = 0; 
    do { 
        ret = poll(&pfd, 1, -1); 
    } while (ret < 0 && (errno == EINTR || errno == EAGAIN)); 
    close(random_fd); 
    return ret; 
} 
#endif 
 
/* return -1 on error */ 
static int dev_urandom_fd(void) { 
    int fd = -1; 
    struct stat st; 
 
    /* Check that fd still points to the correct device */ 
    if (urandom_cache.fd >= 0) { 
        if (fstat(urandom_cache.fd, &st) 
                || st.st_dev != urandom_cache.st_dev 
                || st.st_ino != urandom_cache.st_ino) { 
            /* Somebody replaced our FD. Invalidate our cache but don't 
             * close the fd. */ 
            urandom_cache.fd = -1; 
        } 
    } 
    if (urandom_cache.fd < 0) { 
#ifdef __linux__ 
        if (wait_on_devrandom() < 0) { 
            goto error; 
        } 
#endif 
 
        fd = open_cloexec("/dev/urandom"); 
        if (fd < 0) { 
            goto error; 
        } 
        if (fstat(fd, &st)) { 
            goto error; 
        } 
        /* Another thread initialized the fd */ 
        if (urandom_cache.fd >= 0) { 
            close(fd); 
            return urandom_cache.fd; 
        } 
        urandom_cache.st_dev = st.st_dev; 
        urandom_cache.st_ino = st.st_ino; 
        urandom_cache.fd = fd; 
    } 
    return urandom_cache.fd; 
 
  error: 
    if (fd != -1) { 
        close(fd); 
    } 
    ERR_Cryptography_OSRandom_error( 
        CRYPTOGRAPHY_OSRANDOM_F_DEV_URANDOM_FD, 
        CRYPTOGRAPHY_OSRANDOM_R_DEV_URANDOM_OPEN_FAILED, 
        __FILE__, __LINE__ 
    ); 
    return -1; 
} 
 
static int dev_urandom_read(unsigned char *buffer, int size) { 
    int fd; 
    int n; 
 
    fd = dev_urandom_fd(); 
    if (fd < 0) { 
        return 0; 
    } 
 
    while (size > 0) { 
        do { 
            n = (int)read(fd, buffer, (size_t)size); 
        } while (n < 0 && errno == EINTR); 
 
        if (n <= 0) { 
            ERR_Cryptography_OSRandom_error( 
                CRYPTOGRAPHY_OSRANDOM_F_DEV_URANDOM_READ, 
                CRYPTOGRAPHY_OSRANDOM_R_DEV_URANDOM_READ_FAILED, 
                __FILE__, __LINE__ 
            ); 
            return 0; 
        } 
        buffer += n; 
        size -= n; 
    } 
    return 1; 
} 
 
static void dev_urandom_close(void) { 
    if (urandom_cache.fd >= 0) { 
        int fd; 
        struct stat st; 
 
        if (fstat(urandom_cache.fd, &st) 
                && st.st_dev == urandom_cache.st_dev 
                && st.st_ino == urandom_cache.st_ino) { 
            fd = urandom_cache.fd; 
            urandom_cache.fd = -1; 
            close(fd); 
        } 
    } 
} 
#endif /* CRYPTOGRAPHY_OSRANDOM_NEEDS_DEV_URANDOM */ 
 
/**************************************************************************** 
 * BSD getentropy 
 */ 
#if CRYPTOGRAPHY_OSRANDOM_ENGINE == CRYPTOGRAPHY_OSRANDOM_ENGINE_GETENTROPY 
static const char *Cryptography_osrandom_engine_name = "osrandom_engine getentropy()"; 
 
static int getentropy_works = CRYPTOGRAPHY_OSRANDOM_GETENTROPY_NOT_INIT; 
 
static int osrandom_init(ENGINE *e) { 
#if !defined(__APPLE__) 
    getentropy_works = CRYPTOGRAPHY_OSRANDOM_GETENTROPY_WORKS; 
#else 
    if (__builtin_available(macOS 10.12, *)) { 
        getentropy_works = CRYPTOGRAPHY_OSRANDOM_GETENTROPY_WORKS; 
    } else { 
        getentropy_works = CRYPTOGRAPHY_OSRANDOM_GETENTROPY_FALLBACK; 
        int fd = dev_urandom_fd(); 
        if (fd < 0) { 
            return 0; 
        } 
    } 
#endif 
    return 1; 
} 
 
static int osrandom_rand_bytes(unsigned char *buffer, int size) { 
    int len; 
    int res; 
 
    switch(getentropy_works) { 
#if defined(__APPLE__) 
    case CRYPTOGRAPHY_OSRANDOM_GETENTROPY_FALLBACK: 
        return dev_urandom_read(buffer, size); 
#endif 
    case CRYPTOGRAPHY_OSRANDOM_GETENTROPY_WORKS: 
        while (size > 0) { 
            /* OpenBSD and macOS restrict maximum buffer size to 256. */ 
            len = size > 256 ? 256 : size; 
/* on mac, availability is already checked using `__builtin_available` above */ 
#pragma clang diagnostic push 
#pragma clang diagnostic ignored "-Wunguarded-availability" 
            res = getentropy(buffer, (size_t)len); 
#pragma clang diagnostic pop 
            if (res < 0) { 
                ERR_Cryptography_OSRandom_error( 
                    CRYPTOGRAPHY_OSRANDOM_F_RAND_BYTES, 
                    CRYPTOGRAPHY_OSRANDOM_R_GETENTROPY_FAILED, 
                    __FILE__, __LINE__ 
                ); 
                return 0; 
            } 
            buffer += len; 
            size -= len; 
        } 
        return 1; 
    } 
    __builtin_unreachable(); 
} 
 
static int osrandom_finish(ENGINE *e) { 
    return 1; 
} 
 
static int osrandom_rand_status(void) { 
    return 1; 
} 
 
static const char *osurandom_get_implementation(void) { 
    switch(getentropy_works) { 
    case CRYPTOGRAPHY_OSRANDOM_GETENTROPY_FALLBACK: 
        return "/dev/urandom"; 
    case CRYPTOGRAPHY_OSRANDOM_GETENTROPY_WORKS: 
        return "getentropy"; 
    } 
    __builtin_unreachable(); 
} 
#endif /* CRYPTOGRAPHY_OSRANDOM_ENGINE_GETENTROPY */ 
 
/**************************************************************************** 
 * Linux getrandom engine with fallback to dev_urandom 
 */ 
 
#if CRYPTOGRAPHY_OSRANDOM_ENGINE == CRYPTOGRAPHY_OSRANDOM_ENGINE_GETRANDOM 
static const char *Cryptography_osrandom_engine_name = "osrandom_engine getrandom()"; 
 
static int getrandom_works = CRYPTOGRAPHY_OSRANDOM_GETRANDOM_NOT_INIT; 
 
static int osrandom_init(ENGINE *e) { 
    /* We try to detect working getrandom until we succeed. */ 
    if (getrandom_works != CRYPTOGRAPHY_OSRANDOM_GETRANDOM_WORKS) { 
        long n; 
        char dest[1]; 
        /* if the kernel CSPRNG is not initialized this will block */ 
        n = syscall(SYS_getrandom, dest, sizeof(dest), 0); 
        if (n == sizeof(dest)) { 
            getrandom_works = CRYPTOGRAPHY_OSRANDOM_GETRANDOM_WORKS; 
        } else { 
            int e = errno; 
            switch(e) { 
            case ENOSYS: 
                /* Fallback: Kernel does not support the syscall. */ 
                getrandom_works = CRYPTOGRAPHY_OSRANDOM_GETRANDOM_FALLBACK; 
                break; 
            case EPERM: 
                /* Fallback: seccomp prevents syscall */ 
                getrandom_works = CRYPTOGRAPHY_OSRANDOM_GETRANDOM_FALLBACK; 
                break; 
            default: 
                /* EINTR cannot occur for buflen < 256. */ 
                ERR_Cryptography_OSRandom_error( 
                    CRYPTOGRAPHY_OSRANDOM_F_INIT, 
                    CRYPTOGRAPHY_OSRANDOM_R_GETRANDOM_INIT_FAILED_UNEXPECTED, 
                    "errno", e 
                ); 
                getrandom_works = CRYPTOGRAPHY_OSRANDOM_GETRANDOM_INIT_FAILED; 
                break; 
            } 
        } 
    } 
 
    /* fallback to dev urandom */ 
    if (getrandom_works == CRYPTOGRAPHY_OSRANDOM_GETRANDOM_FALLBACK) { 
        int fd = dev_urandom_fd(); 
        if (fd < 0) { 
            return 0; 
        } 
    } 
    return 1; 
} 
 
static int osrandom_rand_bytes(unsigned char *buffer, int size) { 
    long n; 
 
    switch(getrandom_works) { 
    case CRYPTOGRAPHY_OSRANDOM_GETRANDOM_INIT_FAILED: 
        ERR_Cryptography_OSRandom_error( 
            CRYPTOGRAPHY_OSRANDOM_F_RAND_BYTES, 
            CRYPTOGRAPHY_OSRANDOM_R_GETRANDOM_INIT_FAILED, 
            __FILE__, __LINE__ 
        ); 
        return 0; 
    case CRYPTOGRAPHY_OSRANDOM_GETRANDOM_NOT_INIT: 
        ERR_Cryptography_OSRandom_error( 
            CRYPTOGRAPHY_OSRANDOM_F_RAND_BYTES, 
            CRYPTOGRAPHY_OSRANDOM_R_GETRANDOM_NOT_INIT, 
            __FILE__, __LINE__ 
        ); 
        return 0; 
    case CRYPTOGRAPHY_OSRANDOM_GETRANDOM_FALLBACK: 
        return dev_urandom_read(buffer, size); 
    case CRYPTOGRAPHY_OSRANDOM_GETRANDOM_WORKS: 
        while (size > 0) { 
            do { 
                n = syscall(SYS_getrandom, buffer, size, 0); 
            } while (n < 0 && errno == EINTR); 
 
            if (n <= 0) { 
                ERR_Cryptography_OSRandom_error( 
                    CRYPTOGRAPHY_OSRANDOM_F_RAND_BYTES, 
                    CRYPTOGRAPHY_OSRANDOM_R_GETRANDOM_FAILED, 
                    __FILE__, __LINE__ 
                ); 
                return 0; 
            } 
            buffer += n; 
            size -= (int)n; 
        } 
        return 1; 
    } 
    __builtin_unreachable(); 
} 
 
static int osrandom_finish(ENGINE *e) { 
    dev_urandom_close(); 
    return 1; 
} 
 
static int osrandom_rand_status(void) { 
    switch(getrandom_works) { 
    case CRYPTOGRAPHY_OSRANDOM_GETRANDOM_INIT_FAILED: 
        return 0; 
    case CRYPTOGRAPHY_OSRANDOM_GETRANDOM_NOT_INIT: 
        return 0; 
    case CRYPTOGRAPHY_OSRANDOM_GETRANDOM_FALLBACK: 
        return urandom_cache.fd >= 0; 
    case CRYPTOGRAPHY_OSRANDOM_GETRANDOM_WORKS: 
        return 1; 
    } 
    __builtin_unreachable(); 
} 
 
static const char *osurandom_get_implementation(void) { 
    switch(getrandom_works) { 
    case CRYPTOGRAPHY_OSRANDOM_GETRANDOM_INIT_FAILED: 
        return "<failed>"; 
    case CRYPTOGRAPHY_OSRANDOM_GETRANDOM_NOT_INIT: 
        return "<not initialized>"; 
    case CRYPTOGRAPHY_OSRANDOM_GETRANDOM_FALLBACK: 
        return "/dev/urandom"; 
    case CRYPTOGRAPHY_OSRANDOM_GETRANDOM_WORKS: 
        return "getrandom"; 
    } 
    __builtin_unreachable(); 
} 
#endif /* CRYPTOGRAPHY_OSRANDOM_ENGINE_GETRANDOM */ 
 
/**************************************************************************** 
 * dev_urandom engine for all remaining platforms 
 */ 
 
#if CRYPTOGRAPHY_OSRANDOM_ENGINE == CRYPTOGRAPHY_OSRANDOM_ENGINE_DEV_URANDOM 
static const char *Cryptography_osrandom_engine_name = "osrandom_engine /dev/urandom"; 
 
static int osrandom_init(ENGINE *e) { 
    int fd = dev_urandom_fd(); 
    if (fd < 0) { 
        return 0; 
    } 
    return 1; 
} 
 
static int osrandom_rand_bytes(unsigned char *buffer, int size) { 
    return dev_urandom_read(buffer, size); 
} 
 
static int osrandom_finish(ENGINE *e) { 
    dev_urandom_close(); 
    return 1; 
} 
 
static int osrandom_rand_status(void) { 
    return urandom_cache.fd >= 0; 
} 
 
static const char *osurandom_get_implementation(void) { 
    return "/dev/urandom"; 
} 
#endif /* CRYPTOGRAPHY_OSRANDOM_ENGINE_DEV_URANDOM */ 
 
/**************************************************************************** 
 * ENGINE boiler plate 
 */ 
 
/* This replicates the behavior of the OpenSSL FIPS RNG, which returns a 
   -1 in the event that there is an error when calling RAND_pseudo_bytes. */ 
static int osrandom_pseudo_rand_bytes(unsigned char *buffer, int size) { 
    int res = osrandom_rand_bytes(buffer, size); 
    if (res == 0) { 
        return -1; 
    } else { 
        return res; 
    } 
} 
 
static RAND_METHOD osrandom_rand = { 
    NULL, 
    osrandom_rand_bytes, 
    NULL, 
    NULL, 
    osrandom_pseudo_rand_bytes, 
    osrandom_rand_status, 
}; 
 
static const ENGINE_CMD_DEFN osrandom_cmd_defns[] = { 
    {CRYPTOGRAPHY_OSRANDOM_GET_IMPLEMENTATION, 
     "get_implementation", 
     "Get CPRNG implementation.", 
     ENGINE_CMD_FLAG_NO_INPUT}, 
     {0, NULL, NULL, 0} 
}; 
 
static int osrandom_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f) (void)) { 
    const char *name; 
    size_t len; 
 
    switch (cmd) { 
    case CRYPTOGRAPHY_OSRANDOM_GET_IMPLEMENTATION: 
        /* i: buffer size, p: char* buffer */ 
        name = osurandom_get_implementation(); 
        len = strlen(name); 
        if ((p == NULL) && (i == 0)) { 
            /* return required buffer len */ 
            return (int)len; 
        } 
        if ((p == NULL) || i < 0 || ((size_t)i <= len)) { 
            /* no buffer or buffer too small */ 
            ENGINEerr(ENGINE_F_ENGINE_CTRL, ENGINE_R_INVALID_ARGUMENT); 
            return 0; 
        } 
        strcpy((char *)p, name); 
        return (int)len; 
    default: 
        ENGINEerr(ENGINE_F_ENGINE_CTRL, ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED); 
        return 0; 
    } 
} 
 
/* error reporting */ 
#define ERR_FUNC(func) ERR_PACK(0, func, 0) 
#define ERR_REASON(reason) ERR_PACK(0, 0, reason) 
 
static ERR_STRING_DATA CRYPTOGRAPHY_OSRANDOM_lib_name[] = { 
    {0, "osrandom_engine"}, 
    {0, NULL} 
}; 
 
static ERR_STRING_DATA CRYPTOGRAPHY_OSRANDOM_str_funcs[] = { 
    {ERR_FUNC(CRYPTOGRAPHY_OSRANDOM_F_INIT), 
     "osrandom_init"}, 
    {ERR_FUNC(CRYPTOGRAPHY_OSRANDOM_F_RAND_BYTES), 
     "osrandom_rand_bytes"}, 
    {ERR_FUNC(CRYPTOGRAPHY_OSRANDOM_F_FINISH), 
     "osrandom_finish"}, 
    {ERR_FUNC(CRYPTOGRAPHY_OSRANDOM_F_DEV_URANDOM_FD), 
     "dev_urandom_fd"}, 
    {ERR_FUNC(CRYPTOGRAPHY_OSRANDOM_F_DEV_URANDOM_READ), 
     "dev_urandom_read"}, 
    {0, NULL} 
}; 
 
static ERR_STRING_DATA CRYPTOGRAPHY_OSRANDOM_str_reasons[] = { 
    {ERR_REASON(CRYPTOGRAPHY_OSRANDOM_R_CRYPTACQUIRECONTEXT), 
     "CryptAcquireContext() failed."}, 
    {ERR_REASON(CRYPTOGRAPHY_OSRANDOM_R_CRYPTGENRANDOM), 
     "CryptGenRandom() failed."}, 
    {ERR_REASON(CRYPTOGRAPHY_OSRANDOM_R_CRYPTRELEASECONTEXT), 
     "CryptReleaseContext() failed."}, 
    {ERR_REASON(CRYPTOGRAPHY_OSRANDOM_R_GETENTROPY_FAILED), 
     "getentropy() failed"}, 
    {ERR_REASON(CRYPTOGRAPHY_OSRANDOM_R_DEV_URANDOM_OPEN_FAILED), 
     "open('/dev/urandom') failed."}, 
    {ERR_REASON(CRYPTOGRAPHY_OSRANDOM_R_DEV_URANDOM_READ_FAILED), 
     "Reading from /dev/urandom fd failed."}, 
    {ERR_REASON(CRYPTOGRAPHY_OSRANDOM_R_GETRANDOM_INIT_FAILED), 
     "getrandom() initialization failed."}, 
    {ERR_REASON(CRYPTOGRAPHY_OSRANDOM_R_GETRANDOM_INIT_FAILED_UNEXPECTED), 
     "getrandom() initialization failed with unexpected errno."}, 
    {ERR_REASON(CRYPTOGRAPHY_OSRANDOM_R_GETRANDOM_FAILED), 
     "getrandom() syscall failed."}, 
    {ERR_REASON(CRYPTOGRAPHY_OSRANDOM_R_GETRANDOM_NOT_INIT), 
     "getrandom() engine was not properly initialized."}, 
    {0, NULL} 
}; 
 
static int Cryptography_OSRandom_lib_error_code = 0; 
 
static void ERR_load_Cryptography_OSRandom_strings(void) 
{ 
    if (Cryptography_OSRandom_lib_error_code == 0) { 
        Cryptography_OSRandom_lib_error_code = ERR_get_next_error_library(); 
        ERR_load_strings(Cryptography_OSRandom_lib_error_code, 
                         CRYPTOGRAPHY_OSRANDOM_lib_name); 
        ERR_load_strings(Cryptography_OSRandom_lib_error_code, 
                         CRYPTOGRAPHY_OSRANDOM_str_funcs); 
        ERR_load_strings(Cryptography_OSRandom_lib_error_code, 
                         CRYPTOGRAPHY_OSRANDOM_str_reasons); 
    } 
} 
 
static void ERR_Cryptography_OSRandom_error(int function, int reason, 
                                            char *file, int line) 
{ 
    ERR_PUT_error(Cryptography_OSRandom_lib_error_code, function, reason, 
                  file, line); 
} 
 
/* Returns 1 if successfully added, 2 if engine has previously been added, 
   and 0 for error. */ 
int Cryptography_add_osrandom_engine(void) { 
    ENGINE *e; 
 
    ERR_load_Cryptography_OSRandom_strings(); 
 
    e = ENGINE_by_id(Cryptography_osrandom_engine_id); 
    if (e != NULL) { 
        ENGINE_free(e); 
        return 2; 
    } else { 
        ERR_clear_error(); 
    } 
 
    e = ENGINE_new(); 
    if (e == NULL) { 
        return 0; 
    } 
    if (!ENGINE_set_id(e, Cryptography_osrandom_engine_id) || 
            !ENGINE_set_name(e, Cryptography_osrandom_engine_name) || 
            !ENGINE_set_RAND(e, &osrandom_rand) || 
            !ENGINE_set_init_function(e, osrandom_init) || 
            !ENGINE_set_finish_function(e, osrandom_finish) || 
            !ENGINE_set_cmd_defns(e, osrandom_cmd_defns) || 
            !ENGINE_set_ctrl_function(e, osrandom_ctrl)) { 
        ENGINE_free(e); 
        return 0; 
    } 
    if (!ENGINE_add(e)) { 
        ENGINE_free(e); 
        return 0; 
    } 
    if (!ENGINE_free(e)) { 
        return 0; 
    } 
 
    return 1; 
} 
 
#else 
/* If OpenSSL has no ENGINE support then we don't want 
 * to compile the osrandom engine, but we do need some 
 * placeholders */ 
static const char *Cryptography_osrandom_engine_id = "no-engine-support"; 
static const char *Cryptography_osrandom_engine_name = "osrandom_engine disabled"; 
 
int Cryptography_add_osrandom_engine(void) { 
    return 0; 
} 
 
#endif