security.c File Reference

#include "libxslt.h"
#include <string.h>
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
#include <libxml/uri.h>
#include "xslt.h"
#include "xsltInternals.h"
#include "xsltutils.h"
#include "extensions.h"
#include "security.h"

Include dependency graph for security.c:

Go to the source code of this file.

Classes
struct	_xsltSecurityPrefs

Macros
#define	IN_LIBXSLT

Functions
xsltSecurityPrefsPtr	xsltNewSecurityPrefs (void)
void	xsltFreeSecurityPrefs (xsltSecurityPrefsPtr sec)
int	xsltSetSecurityPrefs (xsltSecurityPrefsPtr sec, xsltSecurityOption option, xsltSecurityCheck func)
xsltSecurityCheck	xsltGetSecurityPrefs (xsltSecurityPrefsPtr sec, xsltSecurityOption option)
void	xsltSetDefaultSecurityPrefs (xsltSecurityPrefsPtr sec)
xsltSecurityPrefsPtr	xsltGetDefaultSecurityPrefs (void)
int	xsltSetCtxtSecurityPrefs (xsltSecurityPrefsPtr sec, xsltTransformContextPtr ctxt)
int	xsltSecurityAllow (xsltSecurityPrefsPtr sec ATTRIBUTE_UNUSED, xsltTransformContextPtr ctxt ATTRIBUTE_UNUSED, const char *value ATTRIBUTE_UNUSED)
int	xsltSecurityForbid (xsltSecurityPrefsPtr sec ATTRIBUTE_UNUSED, xsltTransformContextPtr ctxt ATTRIBUTE_UNUSED, const char *value ATTRIBUTE_UNUSED)
static int	xsltCheckFilename (const char *path)
static int	xsltCheckWritePath (xsltSecurityPrefsPtr sec, xsltTransformContextPtr ctxt, const char *path)
int	xsltCheckWrite (xsltSecurityPrefsPtr sec, xsltTransformContextPtr ctxt, const xmlChar *URL)
int	xsltCheckRead (xsltSecurityPrefsPtr sec, xsltTransformContextPtr ctxt, const xmlChar *URL)

Variables
static xsltSecurityPrefsPtr	xsltDefaultSecurityPrefs = NULL

Macro Definition Documentation

IN_LIBXSLT

#define IN_LIBXSLT

Definition at line 9 of file security.c.

Function Documentation

xsltCheckFilename()

static int xsltCheckFilename ( const char *  path )

static

xsltCheckFilename @path: the path to check

function checks to see if @path is a valid source (file, socket...) for XML.

TODO: remove at some point !!! Local copy of xmlCheckFilename to avoid a hard dependency on a new version of libxml2

if stat is not available on the target machine, returns 1. if stat fails, returns 0 (if calling stat on the filename fails, it can't be right). if stat succeeds and the file is a directory, returns 2. otherwise returns 1.

Definition at line 262 of file security.c.

{
#ifdef HAVE_STAT
    struct stat stat_buffer;
#if defined(_WIN32)
    DWORD dwAttrs;
 
    dwAttrs = GetFileAttributesA(path);
    if (dwAttrs != INVALID_FILE_ATTRIBUTES) {
        if (dwAttrs & FILE_ATTRIBUTE_DIRECTORY) {
            return 2;
        }
    }
#endif
 
    if (stat(path, &stat_buffer) == -1)
        return 0;
 
#ifdef S_ISDIR
    if (S_ISDIR(stat_buffer.st_mode)) {
        return 2;
    }
#endif
#endif
    return 1;
}

Referenced by xsltCheckWritePath().

xsltCheckRead()

int xsltCheckRead	(	xsltSecurityPrefsPtr	sec,
		xsltTransformContextPtr	ctxt,
		const xmlChar *	URL
	)

xsltCheckRead: @sec: the security options @ctxt: an XSLT transformation context @URL: the resource to be read

Check if the resource is allowed to be read

Return 1 if read is allowed, 0 if not and -1 in case or error.

Definition at line 419 of file security.c.

                                                            {
    int ret;
    xmlURIPtr uri;
    xsltSecurityCheck check;
 
    if (xmlStrstr(URL, BAD_CAST "://") == NULL) {
    check = xsltGetSecurityPrefs(sec, XSLT_SECPREF_READ_FILE);
    if (check != NULL) {
            ret = check(sec, ctxt, (const char *) URL);
            if (ret == 0) {
                xsltTransformError(ctxt, NULL, NULL,
                             "Local file read for %s refused\n", URL);
                return(0);
            }
        }
        return(1);
    }
 
    uri = xmlParseURI((const char *)URL);
    if (uri == NULL) {
    xsltTransformError(ctxt, NULL, NULL,
     "xsltCheckRead: URL parsing failed for %s\n",
             URL);
    return(-1);
    }
    if ((uri->scheme == NULL) ||
    (xmlStrEqual(BAD_CAST uri->scheme, BAD_CAST "file"))) {
 
    /*
     * Check if we are allowed to read this file
     */
    check = xsltGetSecurityPrefs(sec, XSLT_SECPREF_READ_FILE);
    if (check != NULL) {
        ret = check(sec, ctxt, uri->path);
        if (ret == 0) {
        xsltTransformError(ctxt, NULL, NULL,
                 "Local file read for %s refused\n", URL);
        xmlFreeURI(uri);
        return(0);
        }
    }
    } else {
    /*
     * Check if we are allowed to write this network resource
     */
    check = xsltGetSecurityPrefs(sec, XSLT_SECPREF_READ_NETWORK);
    if (check != NULL) {
        ret = check(sec, ctxt, (const char *)URL);
        if (ret == 0) {
        xsltTransformError(ctxt, NULL, NULL,
                 "Network file read for %s refused\n", URL);
        xmlFreeURI(uri);
        return(0);
        }
    }
    }
    xmlFreeURI(uri);
    return(1);
}

Referenced by xsltLoadDocument(), xsltLoadStyleDocument(), xsltParseStylesheetFile(), and xsltParseStylesheetImport().

xsltCheckWrite()

int xsltCheckWrite	(	xsltSecurityPrefsPtr	sec,
		xsltTransformContextPtr	ctxt,
		const xmlChar *	URL
	)

xsltCheckWrite: @sec: the security options @ctxt: an XSLT transformation context @URL: the resource to be written

Check if the resource is allowed to be written, if necessary makes some preliminary work like creating directories

Return 1 if write is allowed, 0 if not and -1 in case or error.

Definition at line 352 of file security.c.

                                                             {
    int ret;
    xmlURIPtr uri;
    xsltSecurityCheck check;
 
    uri = xmlParseURI((const char *)URL);
    if (uri == NULL) {
        uri = xmlCreateURI();
    if (uri == NULL) {
        xsltTransformError(ctxt, NULL, NULL,
         "xsltCheckWrite: out of memory for %s\n", URL);
        return(-1);
    }
    uri->path = (char *)xmlStrdup(URL);
    }
    if ((uri->scheme == NULL) ||
    (xmlStrEqual(BAD_CAST uri->scheme, BAD_CAST "file"))) {
 
#if defined(_WIN32)
        if ((uri->path)&&(uri->path[0]=='/')&&
            (uri->path[1]!='\0')&&(uri->path[2]==':'))
            ret = xsltCheckWritePath(sec, ctxt, uri->path+1);
        else
#endif
        {
            /*
             * Check if we are allowed to write this file
             */
        ret = xsltCheckWritePath(sec, ctxt, uri->path);
        }
 
    if (ret <= 0) {
        xmlFreeURI(uri);
        return(ret);
    }
    } else {
    /*
     * Check if we are allowed to write this network resource
     */
    check = xsltGetSecurityPrefs(sec, XSLT_SECPREF_WRITE_NETWORK);
    if (check != NULL) {
        ret = check(sec, ctxt, (const char *)URL);
        if (ret == 0) {
        xsltTransformError(ctxt, NULL, NULL,
                 "File write for %s refused\n", URL);
        xmlFreeURI(uri);
        return(0);
        }
    }
    }
    xmlFreeURI(uri);
    return(1);
}

Referenced by xsltApplyStylesheetInternal(), and xsltDocumentElem().

xsltCheckWritePath()

static int xsltCheckWritePath ( xsltSecurityPrefsPtr  sec, xsltTransformContextPtr  ctxt, const char *  path  )

static

Definition at line 290 of file security.c.

{
    int ret;
    xsltSecurityCheck check;
    char *directory;
 
    check = xsltGetSecurityPrefs(sec, XSLT_SECPREF_WRITE_FILE);
    if (check != NULL) {
    ret = check(sec, ctxt, path);
    if (ret == 0) {
        xsltTransformError(ctxt, NULL, NULL,
                   "File write for %s refused\n", path);
        return(0);
    }
    }
 
    directory = xmlParserGetDirectory (path);
 
    if (directory != NULL) {
    ret = xsltCheckFilename(directory);
    if (ret == 0) {
        /*
         * The directory doesn't exist check for creation
         */
        check = xsltGetSecurityPrefs(sec,
                     XSLT_SECPREF_CREATE_DIRECTORY);
        if (check != NULL) {
        ret = check(sec, ctxt, directory);
        if (ret == 0) {
            xsltTransformError(ctxt, NULL, NULL,
                       "Directory creation for %s refused\n",
                       path);
            xmlFree(directory);
            return(0);
        }
        }
        ret = xsltCheckWritePath(sec, ctxt, directory);
        if (ret == 1)
        ret = mkdir(directory, 0755);
    }
    xmlFree(directory);
    if (ret < 0)
        return(ret);
    }
 
    return(1);
}

Referenced by xsltCheckWrite(), and xsltCheckWritePath().

xsltFreeSecurityPrefs()

void xsltFreeSecurityPrefs

(

xsltSecurityPrefsPtr

sec

)

xsltFreeSecurityPrefs: @sec: the security block to free

Free up a security preference block

Definition at line 95 of file security.c.

                                                {
    if (sec == NULL)
    return;
    xmlFree(sec);
}

xsltGetDefaultSecurityPrefs()

xsltSecurityPrefsPtr xsltGetDefaultSecurityPrefs

(

void

)

xsltGetDefaultSecurityPrefs:

Get the default security preference application-wide

Returns the current xsltSecurityPrefsPtr in use or NULL if none

Definition at line 180 of file security.c.

                                  {
    return(xsltDefaultSecurityPrefs);
}

Referenced by xsltLoadStyleDocument(), xsltNewTransformContext(), xsltParseStylesheetFile(), and xsltParseStylesheetImport().

xsltGetSecurityPrefs()

xsltSecurityCheck xsltGetSecurityPrefs	(	xsltSecurityPrefsPtr	sec,
		xsltSecurityOption	option
	)

xsltGetSecurityPrefs: @sec: the security block to update @option: the option to lookup

Lookup the security option to get the callback checking function

Returns NULL if not found, the function otherwise

Definition at line 142 of file security.c.

                                                                          {
    if (sec == NULL)
    return(NULL);
    switch (option) {
        case XSLT_SECPREF_READ_FILE:
            return(sec->readFile);
        case XSLT_SECPREF_WRITE_FILE:
            return(sec->createFile);
        case XSLT_SECPREF_CREATE_DIRECTORY:
            return(sec->createDir);
        case XSLT_SECPREF_READ_NETWORK:
            return(sec->readNet);
        case XSLT_SECPREF_WRITE_NETWORK:
            return(sec->writeNet);
    }
    return(NULL);
}

Referenced by xsltCheckRead(), xsltCheckWrite(), and xsltCheckWritePath().

xsltNewSecurityPrefs()

xsltSecurityPrefsPtr xsltNewSecurityPrefs

(

void

)

xsltNewSecurityPrefs:

Create a new security preference block

Returns a pointer to the new block or NULL in case of error

Definition at line 73 of file security.c.

                           {
    xsltSecurityPrefsPtr ret;
 
    xsltInitGlobals();
 
    ret = (xsltSecurityPrefsPtr) xmlMalloc(sizeof(xsltSecurityPrefs));
    if (ret == NULL) {
    xsltTransformError(NULL, NULL, NULL,
        "xsltNewSecurityPrefs : malloc failed\n");
    return(NULL);
    }
    memset(ret, 0, sizeof(xsltSecurityPrefs));
    return(ret);
}

xsltSecurityAllow()

int xsltSecurityAllow	(	xsltSecurityPrefsPtr sec	ATTRIBUTE_UNUSED,
		xsltTransformContextPtr ctxt	ATTRIBUTE_UNUSED,
		const char *value	ATTRIBUTE_UNUSED
	)

xsltSecurityAllow: @sec: the security block to use @ctxt: an XSLT transformation context @value: unused

Function used to always allow an operation

Returns 1 always

Definition at line 214 of file security.c.

                                              {
    return(1);
}

xsltSecurityForbid()

int xsltSecurityForbid	(	xsltSecurityPrefsPtr sec	ATTRIBUTE_UNUSED,
		xsltTransformContextPtr ctxt	ATTRIBUTE_UNUSED,
		const char *value	ATTRIBUTE_UNUSED
	)

xsltSecurityForbid: @sec: the security block to use @ctxt: an XSLT transformation context @value: unused

Function used to always forbid an operation

Returns 0 always

Definition at line 231 of file security.c.

                                              {
    return(0);
}

xsltSetCtxtSecurityPrefs()

int xsltSetCtxtSecurityPrefs	(	xsltSecurityPrefsPtr	sec,
		xsltTransformContextPtr	ctxt
	)

xsltSetCtxtSecurityPrefs: @sec: the security block to use @ctxt: an XSLT transformation context

Set the security preference for a specific transformation

Returns -1 in case of error, 0 otherwise

Definition at line 194 of file security.c.

                                                   {
    if (ctxt == NULL)
    return(-1);
    ctxt->sec = (void *) sec;
    return(0);
}

xsltSetDefaultSecurityPrefs()

void xsltSetDefaultSecurityPrefs

(

xsltSecurityPrefsPtr

sec

)

xsltSetDefaultSecurityPrefs: @sec: the security block to use

Set the default security preference application-wide

Definition at line 167 of file security.c.

                                                      {
 
    xsltDefaultSecurityPrefs = sec;
}

xsltSetSecurityPrefs()

int xsltSetSecurityPrefs	(	xsltSecurityPrefsPtr	sec,
		xsltSecurityOption	option,
		xsltSecurityCheck	func
	)

xsltSetSecurityPrefs: @sec: the security block to update @option: the option to update @func: the user callback to use for this option

Update the security option to use the new callback checking function

Returns -1 in case of error, 0 otherwise

Definition at line 112 of file security.c.

                                             {
    xsltInitGlobals();
    if (sec == NULL)
    return(-1);
    switch (option) {
        case XSLT_SECPREF_READ_FILE:
            sec->readFile = func; return(0);
        case XSLT_SECPREF_WRITE_FILE:
            sec->createFile = func; return(0);
        case XSLT_SECPREF_CREATE_DIRECTORY:
            sec->createDir = func; return(0);
        case XSLT_SECPREF_READ_NETWORK:
            sec->readNet = func; return(0);
        case XSLT_SECPREF_WRITE_NETWORK:
            sec->writeNet = func; return(0);
    }
    return(-1);
}

Variable Documentation

xsltDefaultSecurityPrefs

xsltSecurityPrefsPtr xsltDefaultSecurityPrefs = NULL

static

Definition at line 57 of file security.c.

Referenced by xsltGetDefaultSecurityPrefs(), and xsltSetDefaultSecurityPrefs().