mirror of
https://git.tartarus.org/simon/putty.git
synced 2025-01-08 08:58:00 +00:00
1547c9c1ec
Up until now, it's been a variadic _function_, whose argument list consists of 'const char *' ASCIZ strings to concatenate, terminated by one containing a null pointer. Now, that function is dupcat_fn(), and it's wrapped by a C99 variadic _macro_ called dupcat(), which automatically suffixes the null-pointer terminating argument. This has three benefits. Firstly, it's just less effort at every call site. Secondly, it protects against the risk of accidentally leaving off the NULL, causing arbitrary words of stack memory to be dereferenced as char pointers. And thirdly, it protects against the more subtle risk of writing a bare 'NULL' as the terminating argument, instead of casting it explicitly to a pointer. That last one is necessary because C permits the macro NULL to expand to an integer constant such as 0, so NULL by itself may not have pointer type, and worse, it may not be marshalled in a variadic argument list in the same way as a pointer. (For example, on a 64-bit machine it might only occupy 32 bits. And yet, on another 64-bit platform, it might work just fine, so that you don't notice the mistake!) I was inspired to do this by happening to notice one of those bare NULL terminators, and thinking I'd better check if there were any more. Turned out there were quite a few. Now there are none.
289 lines
9.9 KiB
C
289 lines
9.9 KiB
C
#include "putty.h"
|
|
|
|
#include <string.h>
|
|
#include <limits.h>
|
|
#include "sshgssc.h"
|
|
#include "misc.h"
|
|
|
|
#ifndef NO_GSSAPI
|
|
|
|
static Ssh_gss_stat ssh_gssapi_indicate_mech(struct ssh_gss_library *lib,
|
|
Ssh_gss_buf *mech)
|
|
{
|
|
/* Copy constant into mech */
|
|
mech->length = GSS_MECH_KRB5->length;
|
|
mech->value = GSS_MECH_KRB5->elements;
|
|
return SSH_GSS_OK;
|
|
}
|
|
|
|
static Ssh_gss_stat ssh_gssapi_import_name(struct ssh_gss_library *lib,
|
|
char *host,
|
|
Ssh_gss_name *srv_name)
|
|
{
|
|
struct gssapi_functions *gss = &lib->u.gssapi;
|
|
OM_uint32 min_stat,maj_stat;
|
|
gss_buffer_desc host_buf;
|
|
char *pStr;
|
|
|
|
pStr = dupcat("host@", host);
|
|
|
|
host_buf.value = pStr;
|
|
host_buf.length = strlen(pStr);
|
|
|
|
maj_stat = gss->import_name(&min_stat, &host_buf,
|
|
GSS_C_NT_HOSTBASED_SERVICE, srv_name);
|
|
/* Release buffer */
|
|
sfree(pStr);
|
|
if (maj_stat == GSS_S_COMPLETE) return SSH_GSS_OK;
|
|
return SSH_GSS_FAILURE;
|
|
}
|
|
|
|
static Ssh_gss_stat ssh_gssapi_acquire_cred(struct ssh_gss_library *lib,
|
|
Ssh_gss_ctx *ctx,
|
|
time_t *expiry)
|
|
{
|
|
struct gssapi_functions *gss = &lib->u.gssapi;
|
|
gss_OID_set_desc k5only = { 1, GSS_MECH_KRB5 };
|
|
gss_cred_id_t cred;
|
|
OM_uint32 dummy;
|
|
OM_uint32 time_rec;
|
|
gssapi_ssh_gss_ctx *gssctx = snew(gssapi_ssh_gss_ctx);
|
|
|
|
gssctx->ctx = GSS_C_NO_CONTEXT;
|
|
gssctx->expiry = 0;
|
|
|
|
gssctx->maj_stat =
|
|
gss->acquire_cred(&gssctx->min_stat, GSS_C_NO_NAME, GSS_C_INDEFINITE,
|
|
&k5only, GSS_C_INITIATE, &cred,
|
|
(gss_OID_set *)0, &time_rec);
|
|
|
|
if (gssctx->maj_stat != GSS_S_COMPLETE) {
|
|
sfree(gssctx);
|
|
return SSH_GSS_FAILURE;
|
|
}
|
|
|
|
/*
|
|
* When the credential lifetime is not yet available due to deferred
|
|
* processing, gss_acquire_cred should return a 0 lifetime which is
|
|
* distinct from GSS_C_INDEFINITE which signals a crential that never
|
|
* expires. However, not all implementations get this right, and with
|
|
* Kerberos, initiator credentials always expire at some point. So when
|
|
* lifetime is 0 or GSS_C_INDEFINITE we call gss_inquire_cred_by_mech() to
|
|
* complete deferred processing.
|
|
*/
|
|
if (time_rec == GSS_C_INDEFINITE || time_rec == 0) {
|
|
gssctx->maj_stat =
|
|
gss->inquire_cred_by_mech(&gssctx->min_stat, cred,
|
|
(gss_OID) GSS_MECH_KRB5,
|
|
GSS_C_NO_NAME,
|
|
&time_rec,
|
|
NULL,
|
|
NULL);
|
|
}
|
|
(void) gss->release_cred(&dummy, &cred);
|
|
|
|
if (gssctx->maj_stat != GSS_S_COMPLETE) {
|
|
sfree(gssctx);
|
|
return SSH_GSS_FAILURE;
|
|
}
|
|
|
|
if (time_rec != GSS_C_INDEFINITE)
|
|
gssctx->expiry = time(NULL) + time_rec;
|
|
else
|
|
gssctx->expiry = GSS_NO_EXPIRATION;
|
|
|
|
if (expiry) {
|
|
*expiry = gssctx->expiry;
|
|
}
|
|
|
|
*ctx = (Ssh_gss_ctx) gssctx;
|
|
return SSH_GSS_OK;
|
|
}
|
|
|
|
static Ssh_gss_stat ssh_gssapi_init_sec_context(struct ssh_gss_library *lib,
|
|
Ssh_gss_ctx *ctx,
|
|
Ssh_gss_name srv_name,
|
|
int to_deleg,
|
|
Ssh_gss_buf *recv_tok,
|
|
Ssh_gss_buf *send_tok,
|
|
time_t *expiry,
|
|
unsigned long *lifetime)
|
|
{
|
|
struct gssapi_functions *gss = &lib->u.gssapi;
|
|
gssapi_ssh_gss_ctx *gssctx = (gssapi_ssh_gss_ctx*) *ctx;
|
|
OM_uint32 ret_flags;
|
|
OM_uint32 lifetime_rec;
|
|
|
|
if (to_deleg) to_deleg = GSS_C_DELEG_FLAG;
|
|
gssctx->maj_stat = gss->init_sec_context(&gssctx->min_stat,
|
|
GSS_C_NO_CREDENTIAL,
|
|
&gssctx->ctx,
|
|
srv_name,
|
|
(gss_OID) GSS_MECH_KRB5,
|
|
GSS_C_MUTUAL_FLAG |
|
|
GSS_C_INTEG_FLAG | to_deleg,
|
|
0,
|
|
GSS_C_NO_CHANNEL_BINDINGS,
|
|
recv_tok,
|
|
NULL, /* ignore mech type */
|
|
send_tok,
|
|
&ret_flags,
|
|
&lifetime_rec);
|
|
|
|
if (lifetime) {
|
|
if (lifetime_rec == GSS_C_INDEFINITE)
|
|
*lifetime = ULONG_MAX;
|
|
else
|
|
*lifetime = lifetime_rec;
|
|
}
|
|
if (expiry) {
|
|
if (lifetime_rec == GSS_C_INDEFINITE)
|
|
*expiry = GSS_NO_EXPIRATION;
|
|
else
|
|
*expiry = time(NULL) + lifetime_rec;
|
|
}
|
|
|
|
if (gssctx->maj_stat == GSS_S_COMPLETE) return SSH_GSS_S_COMPLETE;
|
|
if (gssctx->maj_stat == GSS_S_CONTINUE_NEEDED) return SSH_GSS_S_CONTINUE_NEEDED;
|
|
return SSH_GSS_FAILURE;
|
|
}
|
|
|
|
static Ssh_gss_stat ssh_gssapi_display_status(struct ssh_gss_library *lib,
|
|
Ssh_gss_ctx ctx,
|
|
Ssh_gss_buf *buf)
|
|
{
|
|
struct gssapi_functions *gss = &lib->u.gssapi;
|
|
gssapi_ssh_gss_ctx *gssctx = (gssapi_ssh_gss_ctx *) ctx;
|
|
OM_uint32 lmin,lmax;
|
|
OM_uint32 ccc;
|
|
gss_buffer_desc msg_maj=GSS_C_EMPTY_BUFFER;
|
|
gss_buffer_desc msg_min=GSS_C_EMPTY_BUFFER;
|
|
|
|
/* Return empty buffer in case of failure */
|
|
SSH_GSS_CLEAR_BUF(buf);
|
|
|
|
/* get first mesg from GSS */
|
|
ccc=0;
|
|
lmax=gss->display_status(&lmin,gssctx->maj_stat,GSS_C_GSS_CODE,(gss_OID) GSS_MECH_KRB5,&ccc,&msg_maj);
|
|
|
|
if (lmax != GSS_S_COMPLETE) return SSH_GSS_FAILURE;
|
|
|
|
/* get first mesg from Kerberos */
|
|
ccc=0;
|
|
lmax=gss->display_status(&lmin,gssctx->min_stat,GSS_C_MECH_CODE,(gss_OID) GSS_MECH_KRB5,&ccc,&msg_min);
|
|
|
|
if (lmax != GSS_S_COMPLETE) {
|
|
gss->release_buffer(&lmin, &msg_maj);
|
|
return SSH_GSS_FAILURE;
|
|
}
|
|
|
|
/* copy data into buffer */
|
|
buf->length = msg_maj.length + msg_min.length + 1;
|
|
buf->value = snewn(buf->length + 1, char);
|
|
|
|
/* copy mem */
|
|
memcpy((char *)buf->value, msg_maj.value, msg_maj.length);
|
|
((char *)buf->value)[msg_maj.length] = ' ';
|
|
memcpy((char *)buf->value + msg_maj.length + 1, msg_min.value, msg_min.length);
|
|
((char *)buf->value)[buf->length] = 0;
|
|
/* free mem & exit */
|
|
gss->release_buffer(&lmin, &msg_maj);
|
|
gss->release_buffer(&lmin, &msg_min);
|
|
return SSH_GSS_OK;
|
|
}
|
|
|
|
static Ssh_gss_stat ssh_gssapi_free_tok(struct ssh_gss_library *lib,
|
|
Ssh_gss_buf *send_tok)
|
|
{
|
|
struct gssapi_functions *gss = &lib->u.gssapi;
|
|
OM_uint32 min_stat,maj_stat;
|
|
maj_stat = gss->release_buffer(&min_stat, send_tok);
|
|
|
|
if (maj_stat == GSS_S_COMPLETE) return SSH_GSS_OK;
|
|
return SSH_GSS_FAILURE;
|
|
}
|
|
|
|
static Ssh_gss_stat ssh_gssapi_release_cred(struct ssh_gss_library *lib,
|
|
Ssh_gss_ctx *ctx)
|
|
{
|
|
struct gssapi_functions *gss = &lib->u.gssapi;
|
|
gssapi_ssh_gss_ctx *gssctx = (gssapi_ssh_gss_ctx *) *ctx;
|
|
OM_uint32 min_stat;
|
|
OM_uint32 maj_stat=GSS_S_COMPLETE;
|
|
|
|
if (gssctx == NULL) return SSH_GSS_FAILURE;
|
|
if (gssctx->ctx != GSS_C_NO_CONTEXT)
|
|
maj_stat = gss->delete_sec_context(&min_stat,&gssctx->ctx,GSS_C_NO_BUFFER);
|
|
sfree(gssctx);
|
|
*ctx = NULL;
|
|
|
|
if (maj_stat == GSS_S_COMPLETE) return SSH_GSS_OK;
|
|
return SSH_GSS_FAILURE;
|
|
}
|
|
|
|
|
|
static Ssh_gss_stat ssh_gssapi_release_name(struct ssh_gss_library *lib,
|
|
Ssh_gss_name *srv_name)
|
|
{
|
|
struct gssapi_functions *gss = &lib->u.gssapi;
|
|
OM_uint32 min_stat,maj_stat;
|
|
maj_stat = gss->release_name(&min_stat, srv_name);
|
|
|
|
if (maj_stat == GSS_S_COMPLETE) return SSH_GSS_OK;
|
|
return SSH_GSS_FAILURE;
|
|
}
|
|
|
|
static Ssh_gss_stat ssh_gssapi_get_mic(struct ssh_gss_library *lib,
|
|
Ssh_gss_ctx ctx, Ssh_gss_buf *buf,
|
|
Ssh_gss_buf *hash)
|
|
{
|
|
struct gssapi_functions *gss = &lib->u.gssapi;
|
|
gssapi_ssh_gss_ctx *gssctx = (gssapi_ssh_gss_ctx *) ctx;
|
|
if (gssctx == NULL) return SSH_GSS_FAILURE;
|
|
return gss->get_mic(&(gssctx->min_stat), gssctx->ctx, 0, buf, hash);
|
|
}
|
|
|
|
static Ssh_gss_stat ssh_gssapi_verify_mic(struct ssh_gss_library *lib,
|
|
Ssh_gss_ctx ctx, Ssh_gss_buf *buf,
|
|
Ssh_gss_buf *hash)
|
|
{
|
|
struct gssapi_functions *gss = &lib->u.gssapi;
|
|
gssapi_ssh_gss_ctx *gssctx = (gssapi_ssh_gss_ctx *) ctx;
|
|
if (gssctx == NULL) return SSH_GSS_FAILURE;
|
|
return gss->verify_mic(&(gssctx->min_stat), gssctx->ctx, buf, hash, NULL);
|
|
}
|
|
|
|
static Ssh_gss_stat ssh_gssapi_free_mic(struct ssh_gss_library *lib,
|
|
Ssh_gss_buf *hash)
|
|
{
|
|
/* On Unix this is the same freeing process as ssh_gssapi_free_tok. */
|
|
return ssh_gssapi_free_tok(lib, hash);
|
|
}
|
|
|
|
void ssh_gssapi_bind_fns(struct ssh_gss_library *lib)
|
|
{
|
|
lib->indicate_mech = ssh_gssapi_indicate_mech;
|
|
lib->import_name = ssh_gssapi_import_name;
|
|
lib->release_name = ssh_gssapi_release_name;
|
|
lib->init_sec_context = ssh_gssapi_init_sec_context;
|
|
lib->free_tok = ssh_gssapi_free_tok;
|
|
lib->acquire_cred = ssh_gssapi_acquire_cred;
|
|
lib->release_cred = ssh_gssapi_release_cred;
|
|
lib->get_mic = ssh_gssapi_get_mic;
|
|
lib->verify_mic = ssh_gssapi_verify_mic;
|
|
lib->free_mic = ssh_gssapi_free_mic;
|
|
lib->display_status = ssh_gssapi_display_status;
|
|
}
|
|
|
|
#else
|
|
|
|
/* Dummy function so this source file defines something if NO_GSSAPI
|
|
is defined. */
|
|
|
|
int ssh_gssapi_init(void)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
#endif
|