Print this page
first pass


  72 static void g_make_token_header(gss_OID mech, int body_size,
  73                                 unsigned char **buf, int tok_type);
  74 static int g_verify_token_header(gss_OID mech, int *body_size,
  75                                 unsigned char **buf_in, int tok_type,
  76                                 int toksize);
  77 
  78 /* private global variables */
  79 static int dummy_token_nums;
  80 
  81 /*
  82  * This OID:
  83  * { iso(1) org(3) internet(6) dod(1) private(4) enterprises(1) sun(42)
  84  * products(2) gssapi(26) mechtypes(1) dummy(2) }
  85  */
  86 
  87 static struct gss_config dummy_mechanism =
  88         {{10, "\053\006\001\004\001\052\002\032\001\002"},
  89         NULL,   /* context */
  90         NULL,   /* next */
  91         TRUE,   /* uses_kmod */
  92 /* EXPORT DELETE START */ /* CRYPT DELETE START */
  93         dummy_gss_unseal,
  94 /* EXPORT DELETE END */ /* CRYPT DELETE END */
  95         dummy_gss_delete_sec_context,
  96 /* EXPORT DELETE START */ /* CRYPT DELETE START */
  97         dummy_gss_seal,
  98 /* EXPORT DELETE END */ /* CRYPT DELETE END */
  99         dummy_gss_import_sec_context,
 100 /* EXPORT DELETE START */
 101 /* CRYPT DELETE START */
 102 #if 0
 103 /* CRYPT DELETE END */
 104         dummy_gss_seal,
 105         dummy_gss_unseal,
 106 /* CRYPT DELETE START */
 107 #endif
 108 /* CRYPT DELETE END */
 109 /* EXPORT DELETE END */
 110         dummy_gss_sign,
 111         dummy_gss_verify
 112 };
 113 
 114 static gss_mechanism
 115 gss_mech_initialize()
 116 {
 117         dprintf("Entering gss_mech_initialize\n");
 118 
 119         if (dummy_token_nums == 0)
 120                 dummy_token_nums = 1;
 121 
 122         dprintf("Leaving gss_mech_initialize\n");
 123         return (&dummy_mechanism);
 124 }
 125 
 126 /*
 127  * Clean up after a failed mod_install()
 128  */
 129 static void


 258 
 259         ctx = (dummy_gss_ctx_id_rec *) context_handle;
 260         ASSERT(ctx->established == 1);
 261         ASSERT(ctx->token_number == MAGIC_TOKEN_NUMBER);
 262         /* Check for defective input token. */
 263 
 264         ptr = (unsigned char *) token_buffer->value;
 265         if (err = g_verify_token_header((gss_OID)gss_mech_dummy, &bodysize,
 266                                         &ptr, 0,
 267                                         token_buffer->length)) {
 268                 *minor_status = err;
 269                 return (GSS_S_DEFECTIVE_TOKEN);
 270         }
 271 
 272         *qop_state = GSS_C_QOP_DEFAULT;
 273 
 274         dprintf("Leaving gss_verify\n");
 275         return (GSS_S_COMPLETE);
 276 }
 277 
 278 /* EXPORT DELETE START */
 279 /*ARGSUSED*/
 280 static OM_uint32
 281 dummy_gss_seal(context, minor_status, context_handle, conf_req_flag,
 282                 qop_req, input_message_buffer, conf_state,
 283                 output_message_buffer, gssd_ctx_verifier)
 284         void *context;
 285         OM_uint32 *minor_status;
 286         gss_ctx_id_t context_handle;
 287         int conf_req_flag;
 288         int qop_req;
 289         gss_buffer_t input_message_buffer;
 290         int *conf_state;
 291         gss_buffer_t output_message_buffer;
 292         OM_uint32 gssd_ctx_verifier;
 293 {
 294         gss_buffer_desc output;
 295         dummy_gss_ctx_id_rec    *ctx;
 296         dprintf("Entering gss_seal\n");
 297 
 298         if (context_handle == GSS_C_NO_CONTEXT)


 346         if (err = g_verify_token_header((gss_OID)gss_mech_dummy, &bodysize,
 347                                         &ptr, 0,
 348                                         input_message_buffer->length)) {
 349                 *minor_status = err;
 350                 return (GSS_S_DEFECTIVE_TOKEN);
 351         }
 352         output.length = bodysize;
 353         output.value = (void *)MALLOC(output.length);
 354         (void) memcpy(output.value, ptr, output.length);
 355 
 356         *output_message_buffer = output;
 357         *qop_state = GSS_C_QOP_DEFAULT;
 358 
 359         if (conf_state)
 360                 *conf_state = 1;
 361 
 362         dprintf("Leaving gss_unseal\n");
 363         return (GSS_S_COMPLETE);
 364 }
 365 
 366 /* EXPORT DELETE END */
 367 
 368 /*ARGSUSED*/
 369 OM_uint32
 370         dummy_gss_import_sec_context(ct, minor_status, interprocess_token,
 371                                         context_handle)
 372 void *ct;
 373 OM_uint32 *minor_status;
 374 gss_buffer_t interprocess_token;
 375 gss_ctx_id_t *context_handle;
 376 {
 377         unsigned char *ptr;
 378         int bodysize;
 379         int err;
 380 
 381         /* Assume that we got ctx from the interprocess token. */
 382         dummy_gss_ctx_id_t ctx;
 383 
 384         dprintf("Entering import_sec_context\n");
 385         ptr = (unsigned char *) interprocess_token->value;
 386         if (err = g_verify_token_header((gss_OID)gss_mech_dummy, &bodysize,
 387                                         &ptr, 0,




  72 static void g_make_token_header(gss_OID mech, int body_size,
  73                                 unsigned char **buf, int tok_type);
  74 static int g_verify_token_header(gss_OID mech, int *body_size,
  75                                 unsigned char **buf_in, int tok_type,
  76                                 int toksize);
  77 
  78 /* private global variables */
  79 static int dummy_token_nums;
  80 
  81 /*
  82  * This OID:
  83  * { iso(1) org(3) internet(6) dod(1) private(4) enterprises(1) sun(42)
  84  * products(2) gssapi(26) mechtypes(1) dummy(2) }
  85  */
  86 
  87 static struct gss_config dummy_mechanism =
  88         {{10, "\053\006\001\004\001\052\002\032\001\002"},
  89         NULL,   /* context */
  90         NULL,   /* next */
  91         TRUE,   /* uses_kmod */

  92         dummy_gss_unseal,

  93         dummy_gss_delete_sec_context,

  94         dummy_gss_seal,

  95         dummy_gss_import_sec_context,










  96         dummy_gss_sign,
  97         dummy_gss_verify
  98 };
  99 
 100 static gss_mechanism
 101 gss_mech_initialize()
 102 {
 103         dprintf("Entering gss_mech_initialize\n");
 104 
 105         if (dummy_token_nums == 0)
 106                 dummy_token_nums = 1;
 107 
 108         dprintf("Leaving gss_mech_initialize\n");
 109         return (&dummy_mechanism);
 110 }
 111 
 112 /*
 113  * Clean up after a failed mod_install()
 114  */
 115 static void


 244 
 245         ctx = (dummy_gss_ctx_id_rec *) context_handle;
 246         ASSERT(ctx->established == 1);
 247         ASSERT(ctx->token_number == MAGIC_TOKEN_NUMBER);
 248         /* Check for defective input token. */
 249 
 250         ptr = (unsigned char *) token_buffer->value;
 251         if (err = g_verify_token_header((gss_OID)gss_mech_dummy, &bodysize,
 252                                         &ptr, 0,
 253                                         token_buffer->length)) {
 254                 *minor_status = err;
 255                 return (GSS_S_DEFECTIVE_TOKEN);
 256         }
 257 
 258         *qop_state = GSS_C_QOP_DEFAULT;
 259 
 260         dprintf("Leaving gss_verify\n");
 261         return (GSS_S_COMPLETE);
 262 }
 263 

 264 /*ARGSUSED*/
 265 static OM_uint32
 266 dummy_gss_seal(context, minor_status, context_handle, conf_req_flag,
 267                 qop_req, input_message_buffer, conf_state,
 268                 output_message_buffer, gssd_ctx_verifier)
 269         void *context;
 270         OM_uint32 *minor_status;
 271         gss_ctx_id_t context_handle;
 272         int conf_req_flag;
 273         int qop_req;
 274         gss_buffer_t input_message_buffer;
 275         int *conf_state;
 276         gss_buffer_t output_message_buffer;
 277         OM_uint32 gssd_ctx_verifier;
 278 {
 279         gss_buffer_desc output;
 280         dummy_gss_ctx_id_rec    *ctx;
 281         dprintf("Entering gss_seal\n");
 282 
 283         if (context_handle == GSS_C_NO_CONTEXT)


 331         if (err = g_verify_token_header((gss_OID)gss_mech_dummy, &bodysize,
 332                                         &ptr, 0,
 333                                         input_message_buffer->length)) {
 334                 *minor_status = err;
 335                 return (GSS_S_DEFECTIVE_TOKEN);
 336         }
 337         output.length = bodysize;
 338         output.value = (void *)MALLOC(output.length);
 339         (void) memcpy(output.value, ptr, output.length);
 340 
 341         *output_message_buffer = output;
 342         *qop_state = GSS_C_QOP_DEFAULT;
 343 
 344         if (conf_state)
 345                 *conf_state = 1;
 346 
 347         dprintf("Leaving gss_unseal\n");
 348         return (GSS_S_COMPLETE);
 349 }
 350 


 351 /*ARGSUSED*/
 352 OM_uint32
 353         dummy_gss_import_sec_context(ct, minor_status, interprocess_token,
 354                                         context_handle)
 355 void *ct;
 356 OM_uint32 *minor_status;
 357 gss_buffer_t interprocess_token;
 358 gss_ctx_id_t *context_handle;
 359 {
 360         unsigned char *ptr;
 361         int bodysize;
 362         int err;
 363 
 364         /* Assume that we got ctx from the interprocess token. */
 365         dummy_gss_ctx_id_t ctx;
 366 
 367         dprintf("Entering import_sec_context\n");
 368         ptr = (unsigned char *) interprocess_token->value;
 369         if (err = g_verify_token_header((gss_OID)gss_mech_dummy, &bodysize,
 370                                         &ptr, 0,