/*

 *  Detect environment for bytecode.

 *

 *  Copyright (C) 2013-2024 Cisco Systems, Inc. and/or its affiliates. All rights reserved.

 *  Copyright (C) 2009-2013 Sourcefire, Inc.

 *

 *  Authors: Török Edvin

 *

 *  This program is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License version 2 as

 *  published by the Free Software Foundation.

 *

 *  This program is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this program; if not, write to the Free Software

 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 *  MA 02110-1301, USA.

 */

#if HAVE_CONFIG_H

#include "clamav-config.h"

#endif

#include "clamav.h"

#include "target.h"

#include "bytecode_detect.h"

#include "others.h"

#include <string.h>

#include <stdio.h>

#include <errno.h>

#ifdef HAVE_UNAME_SYSCALL

#include <sys/utsname.h>

#endif

#define CHECK_ARCH(a) \

    if (!strcmp(TARGET_ARCH_TYPE, #a)) env->arch = arch_##a

extern bool have_clamjit(void);

static void cli_print_environment(struct cli_environment *env)

{

    uint32_t id_a = env->platform_id_a;

    uint32_t id_b = env->platform_id_b;

    uint32_t id_c = env->platform_id_c;

    /* the bytecode instruction that exactly identifies this platform */

    /* the space separated groups can be a concrete value, or 0xff for ANY */

    cli_dbgmsg("environment detected:\n");

    cli_dbgmsg("check_platform(0x%08x, 0x%08x, 0x%08x)\n",

               id_a, id_b, id_c);

    cli_dbgmsg("check_platform(0x%02x  %01x  %01x  %02x  %02x,"

               "0x%01x  %01x       %02x %02x %02x,"

               "0x%02x    %02x %02x %02x)\n",

               env->os_category, env->arch, env->compiler,

               env->functionality_level,

               env->dconf_level,

               env->big_endian,

               env->sizeof_ptr,

               (env->cpp_version >> 16) & 0xff,

               (env->cpp_version >> 8) & 0xff,

               env->cpp_version & 0xff,

               env->os_features,

               (env->c_version >> 16) & 0xff,

               (env->c_version >> 8) & 0xff,

               env->c_version & 0xff);

    cli_dbgmsg("check_platform( OS CPU COM FL DCONF,BE PTR CXX VV.VV.VV, FLG CC VV.VV.VV)\n");

    cli_dbgmsg("Engine version: %s\n", env->engine_version);

    cli_dbgmsg("Host triple: %s\n", env->triple);

    cli_dbgmsg("Host CPU: %s\n", env->cpu);

    cli_dbgmsg("OS: %s\n", env->sysname);

    cli_dbgmsg("OS release: %s\n", env->release);

    cli_dbgmsg("OS version: %s\n", env->version);

    cli_dbgmsg("OS hardware: %s\n", env->machine);

    cli_dbgmsg("OS LLVM category: %d\n", env->os);

    cli_dbgmsg("Has JIT compiled: %d\n", env->has_jit_compiled);

    cli_dbgmsg("------------------------------------------------------\n");

}

#ifdef __linux__

static int detect_PaX(void)

{

    char line[128];

    int pax = 0;

    FILE *f = fopen("/proc/self/status", "r");

    if (!f)

        return 0;

    while (fgets(line, sizeof(line), f)) {

        if (!memcmp(line, "PaX:", 4)) {

            pax = 1;

            if (!strchr(line, 'm'))

                pax = 2;

            break;

        }

    }

    fclose(f);

    return pax;

}

static int detect_SELinux(void)

{

    char line[128];

    int selinux = 0;

    int enforce = 0;

    FILE *f     = fopen("/proc/filesystems", "r");

    if (!f) {

        f = fopen("/selinux/enforce", "r");

        if (!f && errno == EACCES)

            return 2;

        if (f) {

            if (fscanf(f, "%d", &enforce) == 1)

                selinux = 2;

            fclose(f);

        }

        return selinux;

    }

    while (fgets(line, sizeof(line), f)) {

        if (strstr(line, "selinuxfs\n")) {

            selinux = 1;

            break;

        }

    }

    fclose(f);

    if (!selinux)

        return 0;

    f = fopen("/selinux/enforce", "r");

    if (f) {

        if (fscanf(f, "%d", &enforce) == 1) {

            if (enforce == 1)

                selinux = 2;

            if (enforce == -1)

                selinux = 0;

        }

        fclose(f);

    }

    return selinux;

}

static void detect_os_features(uint8_t *os_features)

{

    int features = 0;

    switch (detect_PaX()) {

        case 2:

            features |= 1 << feature_pax_mprotect;

            /* fall through */

        case 1:

            features |= 1 << feature_pax;

            break;

        default:

            break;

    }

    switch (detect_SELinux()) {

        case 2:

            features |= 1 << feature_selinux_enforcing;

            /* fall through */

        case 1:

            features |= 1 << feature_selinux;

            break;

        default:

            break;

    }

    *os_features = features;

}

#else

static void detect_os_features(uint8_t *os_features)

{

    *os_features = 0;

}

#endif

/* OS features :

 * Linux: PaX << 2| SELinux << 1| mmap-RWX

 * Other:                         mmap-RWX */

void cli_detect_environment(struct cli_environment *env)

{

    memset(env, 0, sizeof(*env));

#if WORDS_BIGENDIAN == 0

    env->big_endian = 0;

#else

    env->big_endian  = 1;

#endif

    env->sizeof_ptr = sizeof(void *);

    /* -- Detect arch -- */

    CHECK_ARCH(i386);

    else CHECK_ARCH(x86_64);

    else if (!strcmp(TARGET_ARCH_TYPE, "amd64")) env->arch = arch_x86_64;

    else if (!strcmp(TARGET_ARCH_TYPE, "AMD64")) env->arch = arch_x86_64;

    else if (!strcmp(TARGET_ARCH_TYPE, "ppc")) env->arch   = arch_ppc32; /* llvm will fix ppc64 */

    else CHECK_ARCH(arm);

    else CHECK_ARCH(sparc);

    else CHECK_ARCH(sparc64);

    else CHECK_ARCH(mips);

    else CHECK_ARCH(mips64);

    else CHECK_ARCH(alpha);

    else CHECK_ARCH(hppa1);

    else CHECK_ARCH(hppa2);

    else CHECK_ARCH(m68k);

    else env->arch = arch_unknown;

    /* -- Detect OS -- */

#ifdef C_AIX

    env->os_category = os_aix;

#elif defined(C_BEOS)

    env->os_category = os_beos;

    /* DARWIN must come before BSD since it defines both */

#elif defined(C_DARWIN)

    env->os_category = os_darwin;

#elif defined(C_BSD)

    env->os_category = os_bsd;

#elif defined(C_GNU_HURD)

    env->os_category = os_gnu_hurd;

#elif defined(C_HPUX)

    env->os_category = os_hpux;

#elif defined(C_INTERIX)

    env->os_category = os_interix;

#elif defined(C_IRIX)

    env->os_category = os_irix;

#elif defined(C_KFREEBSD_GNU)

    env->os_category = os_kfreebsd_gnu;

#elif defined(C_LINUX)

    env->os_category = os_linux;

#elif defined(C_OS2)

    env->os_category = os_os2;

#elif defined(C_OSF)

    env->os_category = os_osf;

#elif defined(C_QNX6)

    env->os_category = os_qnx6;

#elif defined(C_SOLARIS)

    env->os_category = os_solaris;

#elif defined(_WIN64)

    env->os_category = os_win64;

#elif defined(_WIN32)

    env->os_category = os_win32;

#else

    env->os_category = os_generic;

#endif

    env->os = llvm_os_UnknownOS;

    /* -- Detect compiler -- */

    /* check GNUC last, because some other compilers might define it */

#ifdef __INTEL_COMPILER

    env->compiler  = compiler_intel;

    env->c_version = __INTEL_COMPILER;

#elif defined(_MSC_VER)

    env->compiler  = compiler_msc;

    env->c_version = _MSC_VER;

#elif defined(__SUNPRO_C)

    env->compiler    = compiler_sun;

    env->c_version   = __SUNPRO_C;

#elif defined(__GNUC__)

#ifdef __clang__

    env->compiler    = compiler_clang;

#elif defined(__llvm__)

    env->compiler = compiler_llvm;

#else

    env->compiler = compiler_gnuc;

#endif

    env->c_version =

        MAKE_VERSION(0, __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__);

#else

    env->compiler    = compiler_other;

    env->c_version   = 0;

#endif

    env->cpp_version = 0;

    env->has_jit_compiled = have_clamjit();

    /* engine */

    env->functionality_level = cl_retflevel();

    env->dconf_level         = CL_FLEVEL_DCONF;

    INIT_STRFIELD(env->engine_version, cl_retver());

#ifdef HAVE_UNAME_SYSCALL

    {

        struct utsname name;

        if (uname(&name) == 0) {

            INIT_STRFIELD(env->sysname, name.sysname);

            INIT_STRFIELD(env->release, name.release);

            INIT_STRFIELD(env->version, name.version);

            INIT_STRFIELD(env->machine, name.machine);

        }

    }

#endif

#ifdef _WIN32

    {

        OSVERSIONINFOEX info;

        info.dwOSVersionInfoSize = sizeof(info);

        if (GetVersionEx((OSVERSIONINFO *)&info) != 0 && info.dwPlatformId == VER_PLATFORM_WIN32_NT) {

            if (info.wProductType == VER_NT_WORKSTATION)

                INIT_STRFIELD(env->sysname, "Microsoft Windows");

            else

                INIT_STRFIELD(env->sysname, "Microsoft Windows Server");

            snprintf((char *)env->release, sizeof(env->release), "%d.%d SP%d.%d",

                     info.dwMajorVersion, info.dwMinorVersion,

                     info.wServicePackMajor, info.wServicePackMinor);

            snprintf((char *)env->version, sizeof(env->version), "Build %d",

                     info.dwBuildNumber);

        }

    }

#endif

    if (!env->sysname[0]) {

        INIT_STRFIELD(env->sysname, TARGET_OS_TYPE);

    }

    detect_os_features(&env->os_features);

    cli_detect_env_jit(env);

    env->platform_id_a = (env->os_category << 24) | (env->arch << 20) |

                         (env->compiler << 16) | (env->functionality_level << 8) |

                         (env->dconf_level);

    env->platform_id_b = (env->big_endian << 28) | (env->sizeof_ptr << 24) |

                         env->cpp_version;

    env->platform_id_c = (env->os_features << 24) | env->c_version;

    cli_print_environment(env);

}