unixlib.c File Reference

#include "config.h"
#include <stdarg.h>
#include <stdlib.h>
#include <dirent.h>
#include <fcntl.h>
#include <unistd.h>
#include <dlfcn.h>
#include <sys/stat.h>
#include "ntstatus.h"
#include "windef.h"
#include "winbase.h"
#include "winternl.h"
#include "wincrypt.h"
#include "crypt32_private.h"
#include "wine/debug.h"

Include dependency graph for unixlib.c:

Go to the source code of this file.

Classes
struct	root_cert
struct	DynamicBuffer

Macros
#define	WIN32_NO_STATUS
#define	BASE64_DECODE_PADDING   0x100
#define	BASE64_DECODE_WHITESPACE   0x200
#define	BASE64_DECODE_INVALID   0x300

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (crypt)
static NTSTATUS	process_attach (void *args)
static NTSTATUS	process_detach (void *args)
static NTSTATUS	open_cert_store (void *args)
static NTSTATUS	import_store_key (void *args)
static NTSTATUS	import_store_cert (void *args)
static NTSTATUS	close_cert_store (void *args)
static BYTE *	add_cert (SIZE_T size)
static void	reset_buffer (struct DynamicBuffer *buffer)
static void	add_line_to_buffer (struct DynamicBuffer *buffer, LPCSTR line)
static int	decodeBase64Byte (char c)
static BOOL	base64_to_cert (const char *str)
static void	import_certs_from_file (int fd)
static void	import_certs_from_path (LPCSTR path, BOOL allow_dir)
static BOOL	check_buffer_resize (char **ptr_buf, size_t *buf_size, size_t check_size)
static void	import_certs_from_dir (LPCSTR path)
static void	load_root_certs (void)
static NTSTATUS	enum_root_certs (void *args)
	C_ASSERT (ARRAYSIZE(__wine_unix_call_funcs)==unix_funcs_count)

Variables
static struct list	root_cert_list = LIST_INIT(root_cert_list)
static const char *const	CRYPT_knownLocations []
const unixlib_entry_t	__wine_unix_call_funcs []

Macro Definition Documentation

BASE64_DECODE_INVALID

#define BASE64_DECODE_INVALID   0x300

Definition at line 419 of file unixlib.c.

BASE64_DECODE_PADDING

#define BASE64_DECODE_PADDING   0x100

Definition at line 417 of file unixlib.c.

BASE64_DECODE_WHITESPACE

#define BASE64_DECODE_WHITESPACE   0x200

Definition at line 418 of file unixlib.c.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 40 of file unixlib.c.

Function Documentation

add_cert()

static BYTE * add_cert ( SIZE_T  size )

static

Definition at line 379 of file unixlib.c.

{
    struct root_cert *cert = malloc( offsetof( struct root_cert, data[size] ));
 
    if (!cert) return NULL;
    cert->size = size;
    list_add_tail( &root_cert_list, &cert->entry );
    return cert->data;
}

Referenced by base64_to_cert(), and load_root_certs().

add_line_to_buffer()

static void add_line_to_buffer ( struct DynamicBuffer *  buffer, LPCSTR  line  )

static

Definition at line 402 of file unixlib.c.

{
    if (buffer->used + strlen(line) + 1 > buffer->allocated)
    {
        DWORD new_size = max( max( buffer->allocated * 2, 1024 ), buffer->used + strlen(line) + 1 );
        void *ptr = realloc( buffer->data, new_size );
        if (!ptr) return;
        buffer->data = ptr;
        buffer->allocated = new_size;
        if (!buffer->used) buffer->data[0] = 0;
    }
    strcpy( buffer->data + buffer->used, line );
    buffer->used += strlen(line);
}

Referenced by import_certs_from_file().

base64_to_cert()

static BOOL base64_to_cert ( const char *  str )

static

Definition at line 442 of file unixlib.c.

{
    DWORD i, valid, out, hasPadding;
    BYTE block[4], *data;
 
    for (i = valid = out = hasPadding = 0; str[i]; i++)
    {
        int d = decodeBase64Byte( str[i] );
        if (d == BASE64_DECODE_INVALID) return FALSE;
        if (d == BASE64_DECODE_WHITESPACE) continue;
 
        /* When padding starts, data is not acceptable */
        if (hasPadding && d != BASE64_DECODE_PADDING) return FALSE;
 
        /* Padding after a full block (like "VVVV=") is ok and stops decoding */
        if (d == BASE64_DECODE_PADDING && (valid & 3) == 0) break;
 
        valid++;
        if (d == BASE64_DECODE_PADDING)
        {
            hasPadding = 1;
            /* When padding reaches a full block, stop decoding */
            if ((valid & 3) == 0) break;
            continue;
        }
 
        /* out is incremented in the 4-char block as follows: "1-23" */
        if ((valid & 3) != 2) out++;
    }
    /* Fail if the block has bad padding; omitting padding is fine */
    if ((valid & 3) != 0 && hasPadding) return FALSE;
 
    if (!(data = add_cert( out ))) return FALSE;
    for (i = valid = out = 0; str[i]; i++)
    {
        int d = decodeBase64Byte( str[i] );
        if (d == BASE64_DECODE_WHITESPACE) continue;
        if (d == BASE64_DECODE_PADDING) break;
        block[valid & 3] = d;
        valid += 1;
        switch (valid & 3)
        {
        case 1:
            data[out++] = (block[0] << 2);
            break;
        case 2:
            data[out-1] = (block[0] << 2) | (block[1] >> 4);
            break;
        case 3:
            data[out++] = (block[1] << 4) | (block[2] >> 2);
            break;
        case 0:
            data[out++] = (block[2] << 6) | (block[3] >> 0);
            break;
        }
    }
    return TRUE;
}

Referenced by import_certs_from_file().

C_ASSERT()

C_ASSERT

(

ARRAYSIZE(__wine_unix_call_funcs)

= =unix_funcs_count

)

check_buffer_resize()

static BOOL check_buffer_resize ( char **  ptr_buf, size_t *  buf_size, size_t  check_size  )

static

Definition at line 538 of file unixlib.c.

{
    if (check_size > *buf_size)
    {
        void *ptr = realloc(*ptr_buf, check_size);
 
        if (!ptr) return FALSE;
        *buf_size = check_size;
        *ptr_buf = ptr;
    }
    return TRUE;
}

Referenced by import_certs_from_dir().

close_cert_store()

static NTSTATUS close_cert_store ( void *  args )

static

Definition at line 366 of file unixlib.c.

{ return STATUS_DLL_NOT_FOUND; }

Referenced by PFXImportCertStore().

decodeBase64Byte()

static int decodeBase64Byte ( char  c )

inlinestatic

Definition at line 421 of file unixlib.c.

{
    int ret = BASE64_DECODE_INVALID;
 
    if (c >= 'A' && c <= 'Z')
        ret = c - 'A';
    else if (c >= 'a' && c <= 'z')
        ret = c - 'a' + 26;
    else if (c >= '0' && c <= '9')
        ret = c - '0' + 52;
    else if (c == '+')
        ret = 62;
    else if (c == '/')
        ret = 63;
    else if (c == '=')
        ret = BASE64_DECODE_PADDING;
    else if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
        ret = BASE64_DECODE_WHITESPACE;
    return ret;
}

Referenced by base64_to_cert().

enum_root_certs()

static NTSTATUS enum_root_certs ( void *  args )

static

Definition at line 667 of file unixlib.c.

{
    struct enum_root_certs_params *params = args;
    static BOOL loaded;
    struct list *ptr;
    struct root_cert *cert;
 
    if (!loaded) load_root_certs();
    loaded = TRUE;
 
    if (!(ptr = list_head( &root_cert_list ))) return STATUS_NO_MORE_ENTRIES;
    cert = LIST_ENTRY( ptr, struct root_cert, entry );
    *params->needed = cert->size;
    if (cert->size <= params->size)
    {
        memcpy( params->buffer, cert->data, cert->size );
        list_remove( &cert->entry );
        free( cert );
    }
    return STATUS_SUCCESS;
}

Referenced by read_trusted_roots_from_known_locations().

import_certs_from_dir()

static void import_certs_from_dir ( LPCSTR  path )

static

Definition at line 555 of file unixlib.c.

{
    DIR *dir;
 
    dir = opendir(path);
    if (dir)
    {
        size_t path_len = strlen(path), bufsize = 0;
        char *filebuf = NULL;
 
        struct dirent *entry;
        while ((entry = readdir(dir)))
        {
            if (strcmp(entry->d_name, ".") && strcmp(entry->d_name, ".."))
            {
                size_t name_len = strlen(entry->d_name);
 
                if (!check_buffer_resize(&filebuf, &bufsize, path_len + 1 + name_len + 1)) break;
                snprintf(filebuf, bufsize, "%s/%s", path, entry->d_name);
                import_certs_from_path(filebuf, FALSE);
            }
        }
        free(filebuf);
        closedir(dir);
    }
}

Referenced by import_certs_from_path().

import_certs_from_file()

static void import_certs_from_file ( int  fd )

static

Definition at line 502 of file unixlib.c.

{
    FILE *fp = fdopen(fd, "r");
    char line[1024];
    BOOL in_cert = FALSE;
    struct DynamicBuffer saved_cert = { 0, 0, NULL };
    int num_certs = 0;
 
    if (!fp) return;
    TRACE("\n");
    while (fgets(line, sizeof(line), fp))
    {
        static const char header[] = "-----BEGIN CERTIFICATE-----";
        static const char trailer[] = "-----END CERTIFICATE-----";
 
        if (!strncmp(line, header, strlen(header)))
        {
            TRACE("begin new certificate\n");
            in_cert = TRUE;
            reset_buffer(&saved_cert);
        }
        else if (!strncmp(line, trailer, strlen(trailer)))
        {
            TRACE("end of certificate, adding cert\n");
            in_cert = FALSE;
            if (base64_to_cert( saved_cert.data )) num_certs++;
        }
        else if (in_cert) add_line_to_buffer(&saved_cert, line);
    }
    free( saved_cert.data );
    TRACE("Read %d certs\n", num_certs);
    fclose(fp);
}

Referenced by import_certs_from_path().

import_certs_from_path()

static void import_certs_from_path ( LPCSTR  path, BOOL  allow_dir  )

static

Definition at line 586 of file unixlib.c.

{
    int fd;
 
    TRACE("(%s, %d)\n", debugstr_a(path), allow_dir);
 
    fd = open(path, O_RDONLY);
    if (fd != -1)
    {
        struct stat st;
 
        if (fstat(fd, &st) == 0)
        {
            if (S_ISREG(st.st_mode))
                import_certs_from_file(fd);
            else if (S_ISDIR(st.st_mode))
            {
                if (allow_dir)
                    import_certs_from_dir(path);
                else
                    WARN("%s is a directory and directories are disallowed\n",
                     debugstr_a(path));
            }
            else
                ERR("%s: invalid file type\n", path);
        }
        close(fd);
    }
}

Referenced by import_certs_from_dir(), and load_root_certs().

import_store_cert()

static NTSTATUS import_store_cert ( void *  args )

static

Definition at line 365 of file unixlib.c.

{ return STATUS_DLL_NOT_FOUND; }

Referenced by PFXImportCertStore().

import_store_key()

static NTSTATUS import_store_key ( void *  args )

static

Definition at line 364 of file unixlib.c.

{ return STATUS_DLL_NOT_FOUND; }

Referenced by import_key().

load_root_certs()

static void load_root_certs ( void  )

static

Definition at line 626 of file unixlib.c.

{
    unsigned int i;
 
#ifdef __APPLE__
    const SecTrustSettingsDomain domains[] = {
        kSecTrustSettingsDomainSystem,
        kSecTrustSettingsDomainAdmin,
        kSecTrustSettingsDomainUser
    };
    OSStatus status;
    CFArrayRef certs;
    DWORD domain;
 
    for (domain = 0; domain < ARRAY_SIZE(domains); domain++)
    {
        status = SecTrustSettingsCopyCertificates(domains[domain], &certs);
        if (status == noErr)
        {
            for (i = 0; i < CFArrayGetCount(certs); i++)
            {
                SecCertificateRef cert = (SecCertificateRef)CFArrayGetValueAtIndex(certs, i);
                CFDataRef certData;
                if ((status = SecItemExport(cert, kSecFormatX509Cert, 0, NULL, &certData)) == noErr)
                {
                    BYTE *data = add_cert( CFDataGetLength(certData) );
                    if (data) memcpy( data, CFDataGetBytePtr(certData), CFDataGetLength(certData) );
                    CFRelease(certData);
                }
                else
                    WARN("could not export certificate %u to X509 format: 0x%08x\n", i, (unsigned int)status);
            }
            CFRelease(certs);
        }
    }
#endif
 
    for (i = 0; i < ARRAY_SIZE(CRYPT_knownLocations) && list_empty(&root_cert_list); i++)
        import_certs_from_path( CRYPT_knownLocations[i], TRUE );
}

Referenced by enum_root_certs().

open_cert_store()

static NTSTATUS open_cert_store ( void *  args )

static

Definition at line 363 of file unixlib.c.

{ return STATUS_DLL_NOT_FOUND; }

Referenced by PFXImportCertStore().

process_attach()

static NTSTATUS process_attach ( void *  args )

static

Definition at line 361 of file unixlib.c.

{ return STATUS_SUCCESS; }

Referenced by DllMain().

process_detach()

static NTSTATUS process_detach ( void *  args )

static

Definition at line 362 of file unixlib.c.

{ return STATUS_SUCCESS; }

reset_buffer()

static void reset_buffer ( struct DynamicBuffer *  buffer )

inlinestatic

Definition at line 396 of file unixlib.c.

{
    buffer->used = 0;
    if (buffer->data) buffer->data[0] = 0;
}

Referenced by common_splitpath_internal(), import_certs_from_file(), and reset_buffers().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

crypt

)

Variable Documentation

__wine_unix_call_funcs

const unixlib_entry_t __wine_unix_call_funcs[]

Initial value:

=
{
    process_attach,
    process_detach,
    open_cert_store,
    import_store_key,
    import_store_cert,
    close_cert_store,
    enum_root_certs,
}

Definition at line 689 of file unixlib.c.

CRYPT_knownLocations

const char* const CRYPT_knownLocations[]

static

Initial value:

= {
 "/etc/ssl/certs/ca-certificates.crt",
 "/etc/ssl/certs",
 "/etc/pki/tls/certs/ca-bundle.crt",
 "/usr/share/ca-certificates/ca-bundle.crt",
 "/usr/local/share/certs/",
 "/etc/sfw/openssl/certs",
 "/etc/security/cacerts",  
}

Definition at line 616 of file unixlib.c.

Referenced by load_root_certs().

root_cert_list

struct list root_cert_list = LIST_INIT(root_cert_list)

static

Definition at line 377 of file unixlib.c.

Referenced by add_cert(), enum_root_certs(), and load_root_certs().