auth_sspi.h File Reference

#include <rpc/clnt.h>
#include <security.h>

Include dependency graph for auth_sspi.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_sspi_OID_desc
struct	_sspi_buffer_desc
struct	rpc_sspi_sec
struct	rpc_sspi_cred
struct	rpc_sspi_init_res

Macros
#define	SECURITY_WIN32
#define	RPCSEC_SSPI_VERSION   1
#define	sspi_name_t   SEC_CHAR *
#define	sspi_qop_t   uint32_t
#define	SSPI_C_NO_NAME   ((sspi_name_t) NULL)
#define	SSPI_C_NO_BUFFER   ((sspi_buffer_t) NULL)
#define	SSPI_C_NO_CONTEXT   ((PCtxtHandle) NULL)

Typedefs
typedef struct _sspi_OID_desc	sspi_OID_desc
typedef struct _sspi_OID_desc *	sspi_OID
typedef struct _sspi_buffer_desc	sspi_buffer_desc
typedef struct _sspi_buffer_desc *	sspi_buffer_t

Enumerations
enum	rpc_sspi_proc_t { RPCSEC_SSPI_DATA = 0 , RPCSEC_SSPI_INIT = 1 , RPCSEC_SSPI_CONTINUE_INIT = 2 , RPCSEC_SSPI_DESTROY = 3 }
enum	rpc_sspi_svc_t { RPCSEC_SSPI_SVC_NONE = 1 , RPCSEC_SSPI_SVC_INTEGRITY = 2 , RPCSEC_SSPI_SVC_PRIVACY = 3 }

Functions
__BEGIN_DECLS bool_t	xdr_rpc_sspi_cred (XDR *xdrs, struct rpc_sspi_cred *p)
bool_t	xdr_rpc_sspi_init_args (XDR *xdrs, sspi_buffer_desc *p)
bool_t	xdr_rpc_sspi_init_res (XDR *xdrs, struct rpc_sspi_init_res *p)
bool_t	xdr_rpc_sspi_data (XDR *xdrs, xdrproc_t xdr_func, caddr_t xdr_ptr, PCtxtHandle ctx, sspi_qop_t qop, rpc_sspi_svc_t svc, u_int seq)
AUTH *	authsspi_create (CLIENT *, sspi_name_t, struct rpc_sspi_sec *)
AUTH *	authsspi_create_default (CLIENT *, char *, int)
bool_t	authsspi_service (AUTH *auth, int svc)
uint32_t	sspi_get_mic (void *ctx, u_int qop, u_int seq, sspi_buffer_desc *bufin, sspi_buffer_desc *bufout)
uint32_t	sspi_verify_mic (void *ctx, u_int seq, sspi_buffer_desc *bufin, sspi_buffer_desc *bufout, u_int *qop_state)
uint32_t	sspi_wrap (void *ctx, u_int seq, sspi_buffer_desc *bufin, sspi_buffer_desc *bufout, u_int *conf_state)
uint32_t	sspi_unwrap (void *ctx, u_int seq, sspi_buffer_desc *bufin, sspi_buffer_desc *bufout, u_int *conf_state, u_int *qop_state)
void	sspi_release_buffer (sspi_buffer_desc *buf)
uint32_t	sspi_import_name (sspi_buffer_desc *name_in, sspi_name_t *name_out)
void	log_debug (const char *fmt,...)
void	log_status (char *m, uint32_t major, uint32_t minor)
void	log_hexdump (bool_t on, const u_char *title, const u_char *buf, int len, int offset)

Macro Definition Documentation

RPCSEC_SSPI_VERSION

#define RPCSEC_SSPI_VERSION   1

Definition at line 44 of file auth_sspi.h.

SECURITY_WIN32

#define SECURITY_WIN32

Definition at line 26 of file auth_sspi.h.

SSPI_C_NO_BUFFER

#define SSPI_C_NO_BUFFER   ((sspi_buffer_t) NULL)

Definition at line 60 of file auth_sspi.h.

SSPI_C_NO_CONTEXT

#define SSPI_C_NO_CONTEXT   ((PCtxtHandle) NULL)

Definition at line 61 of file auth_sspi.h.

SSPI_C_NO_NAME

#define SSPI_C_NO_NAME   ((sspi_name_t) NULL)

Definition at line 59 of file auth_sspi.h.

sspi_name_t

#define sspi_name_t   SEC_CHAR *

Definition at line 46 of file auth_sspi.h.

sspi_qop_t

#define sspi_qop_t   uint32_t

Definition at line 47 of file auth_sspi.h.

Typedef Documentation

sspi_buffer_desc

typedef struct _sspi_buffer_desc sspi_buffer_desc

sspi_buffer_t

typedef struct _sspi_buffer_desc * sspi_buffer_t

sspi_OID

typedef struct _sspi_OID_desc * sspi_OID

sspi_OID_desc

typedef struct _sspi_OID_desc sspi_OID_desc

Enumeration Type Documentation

rpc_sspi_proc_t

enum rpc_sspi_proc_t

Enumerator
RPCSEC_SSPI_DATA
RPCSEC_SSPI_INIT
RPCSEC_SSPI_CONTINUE_INIT
RPCSEC_SSPI_DESTROY

Definition at line 30 of file auth_sspi.h.

             {
    RPCSEC_SSPI_DATA = 0,
    RPCSEC_SSPI_INIT = 1,
    RPCSEC_SSPI_CONTINUE_INIT = 2,
    RPCSEC_SSPI_DESTROY = 3
} rpc_sspi_proc_t;

rpc_sspi_svc_t

enum rpc_sspi_svc_t

Enumerator
RPCSEC_SSPI_SVC_NONE
RPCSEC_SSPI_SVC_INTEGRITY
RPCSEC_SSPI_SVC_PRIVACY

Definition at line 38 of file auth_sspi.h.

             {
    RPCSEC_SSPI_SVC_NONE = 1,
    RPCSEC_SSPI_SVC_INTEGRITY = 2,
    RPCSEC_SSPI_SVC_PRIVACY = 3
} rpc_sspi_svc_t;

Function Documentation

authsspi_create()

AUTH * authsspi_create	(	CLIENT *	clnt,
		sspi_name_t	name,
		struct rpc_sspi_sec *	sec
	)

Definition at line 74 of file auth_sspi.c.

{
    AUTH *auth, *save_auth;
    struct rpc_sspi_data *gd;
 
    log_debug("in authgss_create()");
 
    memset(&rpc_createerr, 0, sizeof(rpc_createerr));
 
    if ((auth = calloc(sizeof(*auth), 1)) == NULL) {
        rpc_createerr.cf_stat = RPC_SYSTEMERROR;
        rpc_createerr.cf_error.re_errno = ENOMEM;
        return (NULL);
    }
    if ((gd = calloc(sizeof(*gd), 1)) == NULL) {
        rpc_createerr.cf_stat = RPC_SYSTEMERROR;
        rpc_createerr.cf_error.re_errno = ENOMEM;
        free(auth);
        return (NULL);
    }
 
#if 0
    if (name != SSPI_C_NO_NAME) {
        if (gss_duplicate_name(&min_stat, name, &gd->name)
                        != GSS_S_COMPLETE) {
            rpc_createerr.cf_stat = RPC_SYSTEMERROR;
            rpc_createerr.cf_error.re_errno = ENOMEM;
            free(auth);
            return (NULL);
        }
    }
    else
#else
    gd->name = strdup(name);
#endif
 
    gd->clnt = clnt;
    SecInvalidateHandle(&gd->ctx);
    gd->sec = sec;
 
    gd->gc.gc_v = RPCSEC_SSPI_VERSION;
    gd->gc.gc_proc = RPCSEC_SSPI_INIT;
    gd->gc.gc_svc = gd->sec->svc;
 
    auth->ah_ops = &authsspi_ops;
    auth->ah_private = (caddr_t)gd;
 
    save_auth = clnt->cl_auth;
    clnt->cl_auth = auth;
 
    if (!authsspi_refresh(auth, NULL))
        auth = NULL;
 
    clnt->cl_auth = save_auth;
 
    return (auth);
}

Referenced by authsspi_create_default().

authsspi_create_default()

AUTH * authsspi_create_default	(	CLIENT *	clnt,
		char *	service,
		int	svc
	)

Definition at line 133 of file auth_sspi.c.

{
    AUTH *auth = NULL;
    uint32_t maj_stat = 0;
    sspi_buffer_desc sname;
    sspi_name_t name = SSPI_C_NO_NAME;
    unsigned char sec_pkg_name[] = "Kerberos";
    struct rpc_sspi_sec *sec;
 
    log_debug("in authgss_create_default() for %s", service);
 
    sname.value = service;
    sname.length = (int)strlen(service);
#if 0
    maj_stat = gss_import_name(&min_stat, &sname,
        (gss_OID)GSS_C_NT_HOSTBASED_SERVICE,
        &name);
#else
    maj_stat = sspi_import_name(&sname, &name);
#endif
    if (maj_stat != SEC_E_OK) {
        log_debug("authgss_create_default: sspi_import_name failed with %x", maj_stat);
        return (NULL);
    }
    sec = calloc(1, sizeof(struct rpc_sspi_sec));
    if (sec == NULL)
        goto out_err;
    sec->svc = svc;
    // Let's acquire creds here for now
    maj_stat = AcquireCredentialsHandleA(NULL, sec_pkg_name, SECPKG_CRED_BOTH,
        NULL, NULL, NULL, NULL, &sec->cred, &sec->expiry);
    if (maj_stat != SEC_E_OK) {
        log_debug("authgss_create_default: AcquireCredentialsHandleA failed with %x", maj_stat);
        free(sec);
        goto out;
    }
 
    auth = authsspi_create(clnt, name, sec);
    if (auth == NULL)
        goto out_free_sec;
 
out:
    if (name != SSPI_C_NO_NAME) {
#if 0
        gss_release_name(&min_stat, &name);
#else
        free(name);
#endif
    }
 
    return (auth);
out_free_sec:
    if (rpc_createerr.cf_error.re_errno == ENOMEM) {
        FreeCredentialsHandle(&sec->cred);
        free(sec);
    }
out_err:
    rpc_createerr.cf_stat = RPC_SYSTEMERROR;
    rpc_createerr.cf_error.re_errno = ENOMEM;
    goto out;
}

Referenced by create_new_rpc_auth(), and create_rpcsec_auth_client().

authsspi_service()

bool_t authsspi_service	(	AUTH *	auth,
		int	svc
	)

Definition at line 544 of file auth_sspi.c.

{
    struct rpc_sspi_data    *gd;
 
    log_debug("in authgss_service()");
 
    if (!auth) 
        return(FALSE);
    gd = AUTH_PRIVATE(auth);
    if (!gd || !gd->established)
        return (FALSE);
    gd->sec->svc = svc;
    gd->gc.gc_svc = svc;
    return (TRUE);
}

log_debug()

void log_debug	(	const char *	fmt,
			...
	)

Definition at line 977 of file auth_sspi.c.

{
    va_list ap;
 
    va_start(ap, fmt);
    fprintf(fd_out, "%04x: rpcsec_gss: ", GetCurrentThreadId());
    vfprintf(fd_out, fmt, ap);
    fprintf(fd_out, "\n");
    fflush(fd_out);
    va_end(ap);
}

Referenced by _svcauth_gss(), authgss_create(), authgss_create_default(), authgss_destroy(), authgss_destroy_context(), authgss_get_private_data(), authgss_marshal(), authgss_nextverf(), authgss_refresh(), authgss_service(), authgss_unwrap(), authgss_validate(), authgss_wrap(), authsspi_create(), authsspi_create_default(), authsspi_destroy(), authsspi_destroy_context(), authsspi_marshal(), authsspi_nextverf(), authsspi_refresh(), authsspi_service(), authsspi_unwrap(), authsspi_validate(), authsspi_wrap(), print_negotiated_attrs(), sspi_import_name(), svcauth_gss_accept_sec_context(), svcauth_gss_acquire_cred(), svcauth_gss_destroy(), svcauth_gss_import_name(), svcauth_gss_nextverf(), svcauth_gss_release_cred(), svcauth_gss_set_svc_name(), svcauth_gss_unwrap(), svcauth_gss_validate(), svcauth_gss_wrap(), xdr_rpc_gss_cred(), xdr_rpc_gss_init_args(), xdr_rpc_gss_init_res(), xdr_rpc_gss_unwrap_data(), xdr_rpc_gss_wrap_data(), xdr_rpc_sspi_cred(), xdr_rpc_sspi_init_args(), xdr_rpc_sspi_init_res(), xdr_rpc_sspi_unwrap_data(), and xdr_rpc_sspi_wrap_data().

log_hexdump()

void log_hexdump	(	bool_t	on,
		const u_char *	title,
		const u_char *	buf,
		int	len,
		int	offset
	)

Definition at line 942 of file auth_sspi.c.

{
    int i, j, jm, c;
 
    if (!on) return;
 
    fprintf(fd_out, "%04x: %s (len=%d)\n", GetCurrentThreadId(), title, len);
    for (i = 0; i < len; i += 0x10) {
        fprintf(fd_out, "  %04x: ", (u_int)(i + offset));
        jm = len - i;
        jm = jm > 16 ? 16 : jm;
 
        for (j = 0; j < jm; j++) {
            if ((j % 2) == 1)
                fprintf(fd_out, "%02x ", (u_int) buf[i+j]);
            else
                fprintf(fd_out, "%02x", (u_int) buf[i+j]);
        }
        for (; j < 16; j++) {
            if ((j % 2) == 1) fprintf(fd_out, "   ");
            else fprintf(fd_out, "  ");
        }
        fprintf(fd_out, " ");
 
        for (j = 0; j < jm; j++) {
            c = buf[i+j];
            c = isprint(c) ? c : '.';
            fprintf(fd_out, "%c", c);
        }
        fprintf(fd_out, "\n");
    }
    fflush(fd_out);
}

Referenced by authgss_refresh(), authsspi_refresh(), sspi_get_mic(), sspi_unwrap(), sspi_verify_mic(), and sspi_wrap().

log_status()

void log_status	(	char *	m,
		uint32_t	major,
		uint32_t	minor
	)

sspi_get_mic()

uint32_t sspi_get_mic	(	void *	ctx,
		u_int	qop,
		u_int	seq,
		sspi_buffer_desc *	bufin,
		sspi_buffer_desc *	bufout
	)

sspi_import_name()

uint32_t sspi_import_name	(	sspi_buffer_desc *	name_in,
		sspi_name_t *	name_out
	)

Definition at line 735 of file auth_sspi.c.

{
    *name_out = calloc(name_in->length + 5, sizeof(char));
    if (*name_out == NULL)
        return SEC_E_INSUFFICIENT_MEMORY;
 
    strcpy(*name_out, "nfs/");
    strncat(*name_out, name_in->value, name_in->length);
 
    log_debug("imported service name is: %s\n", *name_out);
 
    return SEC_E_OK;
}

Referenced by authsspi_create_default().

sspi_release_buffer()

void sspi_release_buffer

(

sspi_buffer_desc *

buf

)

Definition at line 727 of file auth_sspi.c.

{
    if (buf->value)
        free(buf->value);
    buf->value = NULL;
    buf->length = 0;
}

Referenced by authsspi_destroy_context(), authsspi_marshal(), authsspi_refresh(), xdr_rpc_sspi_unwrap_data(), and xdr_rpc_sspi_wrap_data().

sspi_unwrap()

uint32_t sspi_unwrap	(	void *	ctx,
		u_int	seq,
		sspi_buffer_desc *	bufin,
		sspi_buffer_desc *	bufout,
		u_int *	conf_state,
		u_int *	qop_state
	)

sspi_verify_mic()

uint32_t sspi_verify_mic	(	void *	ctx,
		u_int	seq,
		sspi_buffer_desc *	bufin,
		sspi_buffer_desc *	bufout,
		u_int *	qop_state
	)

sspi_wrap()

uint32_t sspi_wrap	(	void *	ctx,
		u_int	seq,
		sspi_buffer_desc *	bufin,
		sspi_buffer_desc *	bufout,
		u_int *	conf_state
	)

xdr_rpc_sspi_cred()

__BEGIN_DECLS bool_t xdr_rpc_sspi_cred	(	XDR *	xdrs,
		struct rpc_sspi_cred *	p
	)

Definition at line 34 of file authsspi_prot.c.

{
    bool_t xdr_stat;
 
    xdr_stat = (xdr_u_int(xdrs, &p->gc_v) &&
                xdr_enum(xdrs, (enum_t *)&p->gc_proc) &&
                xdr_u_int(xdrs, &p->gc_seq) &&
                xdr_enum(xdrs, (enum_t *)&p->gc_svc) &&
                xdr_bytes(xdrs, (char **)&p->gc_ctx.value,
                (u_int *)&p->gc_ctx.length, MAX_AUTH_BYTES));
 
    log_debug("xdr_rpc_gss_cred: %s %s "
                "(v %d, proc %d, seq %d, svc %d, ctx %p:%d)",
                (xdrs->x_op == XDR_ENCODE) ? "encode" : "decode",
                (xdr_stat == TRUE) ? "success" : "failure",
                p->gc_v, p->gc_proc, p->gc_seq, p->gc_svc,
                p->gc_ctx.value, p->gc_ctx.length);
 
    return (xdr_stat);
}

Referenced by authsspi_marshal().

xdr_rpc_sspi_data()

bool_t xdr_rpc_sspi_data	(	XDR *	xdrs,
		xdrproc_t	xdr_func,
		caddr_t	xdr_ptr,
		PCtxtHandle	ctx,
		sspi_qop_t	qop,
		rpc_sspi_svc_t	svc,
		u_int	seq
	)

Definition at line 288 of file authsspi_prot.c.

{
    switch (xdrs->x_op) {
 
    case XDR_ENCODE:
        return (xdr_rpc_sspi_wrap_data(xdrs, xdr_func, xdr_ptr,
                    ctx, qop, svc, seq));
    case XDR_DECODE:
        return (xdr_rpc_sspi_unwrap_data(xdrs, xdr_func, xdr_ptr,
                    ctx, qop, svc, seq));
    case XDR_FREE:
        return (TRUE);
    }
    return (FALSE);
}

Referenced by authsspi_unwrap(), and authsspi_wrap().

xdr_rpc_sspi_init_args()

bool_t xdr_rpc_sspi_init_args	(	XDR *	xdrs,
		sspi_buffer_desc *	p
	)

Definition at line 56 of file authsspi_prot.c.

{
    bool_t xdr_stat;
 
    xdr_stat = xdr_bytes(xdrs, (char **)&p->value,
                        (u_int *)&p->length, (u_int)(-1));
 
    log_debug("xdr_rpc_gss_init_args: %s %s (token %p:%d)",
                (xdrs->x_op == XDR_ENCODE) ? "encode" : "decode",
                (xdr_stat == TRUE) ? "success" : "failure",
                p->value, p->length);
 
    return (xdr_stat);
}

Referenced by authsspi_refresh().

xdr_rpc_sspi_init_res()

bool_t xdr_rpc_sspi_init_res	(	XDR *	xdrs,
		struct rpc_sspi_init_res *	p
	)

Definition at line 72 of file authsspi_prot.c.

{
    bool_t xdr_stat;
 
    xdr_stat = (xdr_bytes(xdrs, (char **)&p->gr_ctx.value,
                (u_int *)&p->gr_ctx.length, MAX_NETOBJ_SZ) &&
                xdr_u_int(xdrs, &p->gr_major) &&
                xdr_u_int(xdrs, &p->gr_minor) &&
                xdr_u_int(xdrs, &p->gr_win) &&
                xdr_bytes(xdrs, (char **)&p->gr_token.value,
                (u_int *)&p->gr_token.length, (u_int)(-1)));
 
    log_debug("xdr_rpc_gss_init_res %s %s "
                "(ctx %p:%d, maj %d, min %d, win %d, token %p:%d)",
                (xdrs->x_op == XDR_ENCODE) ? "encode" : "decode",
                (xdr_stat == TRUE) ? "success" : "failure",
                p->gr_ctx.value, p->gr_ctx.length,
                p->gr_major, p->gr_minor, p->gr_win,
                p->gr_token.value, p->gr_token.length);
 
    return (xdr_stat);
}

Referenced by authsspi_refresh().