1 // Copyright (c) 2010 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "net/http/mock_gssapi_library_posix.h" 6 7 #include "base/logging.h" 8 #include "base/strings/string_util.h" 9 #include "base/strings/stringprintf.h" 10 #include "testing/gtest/include/gtest/gtest.h" 11 12 namespace net { 13 14 namespace test { 15 16 struct GssNameMockImpl { 17 std::string name; 18 gss_OID_desc name_type; 19 }; 20 21 } // namespace test 22 23 namespace { 24 25 // gss_OID helpers. 26 // NOTE: gss_OID's do not own the data they point to, which should be static. 27 void ClearOid(gss_OID dest) { 28 if (!dest) 29 return; 30 dest->length = 0; 31 dest->elements = NULL; 32 } 33 34 void SetOid(gss_OID dest, const void* src, size_t length) { 35 if (!dest) 36 return; 37 ClearOid(dest); 38 if (!src) 39 return; 40 dest->length = length; 41 if (length) 42 dest->elements = const_cast<void*>(src); 43 } 44 45 void CopyOid(gss_OID dest, const gss_OID_desc* src) { 46 if (!dest) 47 return; 48 ClearOid(dest); 49 if (!src) 50 return; 51 SetOid(dest, src->elements, src->length); 52 } 53 54 // gss_buffer_t helpers. 55 void ClearBuffer(gss_buffer_t dest) { 56 if (!dest) 57 return; 58 dest->length = 0; 59 delete [] reinterpret_cast<char*>(dest->value); 60 dest->value = NULL; 61 } 62 63 void SetBuffer(gss_buffer_t dest, const void* src, size_t length) { 64 if (!dest) 65 return; 66 ClearBuffer(dest); 67 if (!src) 68 return; 69 dest->length = length; 70 if (length) { 71 dest->value = new char[length]; 72 memcpy(dest->value, src, length); 73 } 74 } 75 76 void CopyBuffer(gss_buffer_t dest, const gss_buffer_t src) { 77 if (!dest) 78 return; 79 ClearBuffer(dest); 80 if (!src) 81 return; 82 SetBuffer(dest, src->value, src->length); 83 } 84 85 std::string BufferToString(const gss_buffer_t src) { 86 std::string dest; 87 if (!src) 88 return dest; 89 const char* string = reinterpret_cast<char*>(src->value); 90 dest.assign(string, src->length); 91 return dest; 92 } 93 94 void BufferFromString(const std::string& src, gss_buffer_t dest) { 95 if (!dest) 96 return; 97 SetBuffer(dest, src.c_str(), src.length()); 98 } 99 100 // gss_name_t helpers. 101 void ClearName(gss_name_t dest) { 102 if (!dest) 103 return; 104 test::GssNameMockImpl* name = reinterpret_cast<test::GssNameMockImpl*>(dest); 105 name->name.clear(); 106 ClearOid(&name->name_type); 107 } 108 109 void SetName(gss_name_t dest, const void* src, size_t length) { 110 if (!dest) 111 return; 112 ClearName(dest); 113 if (!src) 114 return; 115 test::GssNameMockImpl* name = reinterpret_cast<test::GssNameMockImpl*>(dest); 116 name->name.assign(reinterpret_cast<const char*>(src), length); 117 } 118 119 std::string NameToString(const gss_name_t& src) { 120 std::string dest; 121 if (!src) 122 return dest; 123 test::GssNameMockImpl* string = 124 reinterpret_cast<test::GssNameMockImpl*>(src); 125 dest = string->name; 126 return dest; 127 } 128 129 void NameFromString(const std::string& src, gss_name_t dest) { 130 if (!dest) 131 return; 132 SetName(dest, src.c_str(), src.length()); 133 } 134 135 } // namespace 136 137 namespace test { 138 139 GssContextMockImpl::GssContextMockImpl() 140 : lifetime_rec(0), 141 ctx_flags(0), 142 locally_initiated(0), 143 open(0) { 144 ClearOid(&mech_type); 145 } 146 147 GssContextMockImpl::GssContextMockImpl(const GssContextMockImpl& other) 148 : src_name(other.src_name), 149 targ_name(other.targ_name), 150 lifetime_rec(other.lifetime_rec), 151 ctx_flags(other.ctx_flags), 152 locally_initiated(other.locally_initiated), 153 open(other.open) { 154 CopyOid(&mech_type, &other.mech_type); 155 } 156 157 GssContextMockImpl::GssContextMockImpl(const char* src_name_in, 158 const char* targ_name_in, 159 OM_uint32 lifetime_rec_in, 160 const gss_OID_desc& mech_type_in, 161 OM_uint32 ctx_flags_in, 162 int locally_initiated_in, 163 int open_in) 164 : src_name(src_name_in ? src_name_in : ""), 165 targ_name(targ_name_in ? targ_name_in : ""), 166 lifetime_rec(lifetime_rec_in), 167 ctx_flags(ctx_flags_in), 168 locally_initiated(locally_initiated_in), 169 open(open_in) { 170 CopyOid(&mech_type, &mech_type_in); 171 } 172 173 GssContextMockImpl::~GssContextMockImpl() { 174 ClearOid(&mech_type); 175 } 176 177 void GssContextMockImpl::Assign( 178 const GssContextMockImpl& other) { 179 if (&other == this) 180 return; 181 src_name = other.src_name; 182 targ_name = other.targ_name; 183 lifetime_rec = other.lifetime_rec; 184 CopyOid(&mech_type, &other.mech_type); 185 ctx_flags = other.ctx_flags; 186 locally_initiated = other.locally_initiated; 187 open = other.open; 188 } 189 190 MockGSSAPILibrary::SecurityContextQuery::SecurityContextQuery() 191 : expected_package(), 192 response_code(0), 193 minor_response_code(0), 194 context_info() { 195 expected_input_token.length = 0; 196 expected_input_token.value = NULL; 197 output_token.length = 0; 198 output_token.value = NULL; 199 } 200 201 MockGSSAPILibrary::SecurityContextQuery::SecurityContextQuery( 202 const std::string& in_expected_package, 203 OM_uint32 in_response_code, 204 OM_uint32 in_minor_response_code, 205 const test::GssContextMockImpl& in_context_info, 206 const char* in_expected_input_token, 207 const char* in_output_token) 208 : expected_package(in_expected_package), 209 response_code(in_response_code), 210 minor_response_code(in_minor_response_code), 211 context_info(in_context_info) { 212 if (in_expected_input_token) { 213 expected_input_token.length = strlen(in_expected_input_token); 214 expected_input_token.value = const_cast<char*>(in_expected_input_token); 215 } else { 216 expected_input_token.length = 0; 217 expected_input_token.value = NULL; 218 } 219 220 if (in_output_token) { 221 output_token.length = strlen(in_output_token); 222 output_token.value = const_cast<char*>(in_output_token); 223 } else { 224 output_token.length = 0; 225 output_token.value = NULL; 226 } 227 } 228 229 MockGSSAPILibrary::SecurityContextQuery::~SecurityContextQuery() {} 230 231 MockGSSAPILibrary::MockGSSAPILibrary() { 232 } 233 234 MockGSSAPILibrary::~MockGSSAPILibrary() { 235 } 236 237 void MockGSSAPILibrary::ExpectSecurityContext( 238 const std::string& expected_package, 239 OM_uint32 response_code, 240 OM_uint32 minor_response_code, 241 const GssContextMockImpl& context_info, 242 const gss_buffer_desc& expected_input_token, 243 const gss_buffer_desc& output_token) { 244 SecurityContextQuery security_query; 245 security_query.expected_package = expected_package; 246 security_query.response_code = response_code; 247 security_query.minor_response_code = minor_response_code; 248 security_query.context_info.Assign(context_info); 249 security_query.expected_input_token = expected_input_token; 250 security_query.output_token = output_token; 251 expected_security_queries_.push_back(security_query); 252 } 253 254 bool MockGSSAPILibrary::Init() { 255 return true; 256 } 257 258 // These methods match the ones in the GSSAPI library. 259 OM_uint32 MockGSSAPILibrary::import_name( 260 OM_uint32* minor_status, 261 const gss_buffer_t input_name_buffer, 262 const gss_OID input_name_type, 263 gss_name_t* output_name) { 264 if (minor_status) 265 *minor_status = 0; 266 if (!output_name) 267 return GSS_S_BAD_NAME; 268 if (!input_name_buffer) 269 return GSS_S_CALL_BAD_STRUCTURE; 270 if (!input_name_type) 271 return GSS_S_BAD_NAMETYPE; 272 GssNameMockImpl* output = new GssNameMockImpl; 273 if (output == NULL) 274 return GSS_S_FAILURE; 275 output->name_type.length = 0; 276 output->name_type.elements = NULL; 277 278 // Save the data. 279 output->name = BufferToString(input_name_buffer); 280 CopyOid(&output->name_type, input_name_type); 281 *output_name = reinterpret_cast<gss_name_t>(output); 282 283 return GSS_S_COMPLETE; 284 } 285 286 OM_uint32 MockGSSAPILibrary::release_name( 287 OM_uint32* minor_status, 288 gss_name_t* input_name) { 289 if (minor_status) 290 *minor_status = 0; 291 if (!input_name) 292 return GSS_S_BAD_NAME; 293 if (!*input_name) 294 return GSS_S_COMPLETE; 295 GssNameMockImpl* name = *reinterpret_cast<GssNameMockImpl**>(input_name); 296 ClearName(*input_name); 297 delete name; 298 *input_name = NULL; 299 return GSS_S_COMPLETE; 300 } 301 302 OM_uint32 MockGSSAPILibrary::release_buffer( 303 OM_uint32* minor_status, 304 gss_buffer_t buffer) { 305 if (minor_status) 306 *minor_status = 0; 307 if (!buffer) 308 return GSS_S_BAD_NAME; 309 ClearBuffer(buffer); 310 return GSS_S_COMPLETE; 311 } 312 313 OM_uint32 MockGSSAPILibrary::display_name( 314 OM_uint32* minor_status, 315 const gss_name_t input_name, 316 gss_buffer_t output_name_buffer, 317 gss_OID* output_name_type) { 318 if (minor_status) 319 *minor_status = 0; 320 if (!input_name) 321 return GSS_S_BAD_NAME; 322 if (!output_name_buffer) 323 return GSS_S_CALL_BAD_STRUCTURE; 324 if (!output_name_type) 325 return GSS_S_CALL_BAD_STRUCTURE; 326 std::string name(NameToString(input_name)); 327 BufferFromString(name, output_name_buffer); 328 GssNameMockImpl* internal_name = 329 *reinterpret_cast<GssNameMockImpl**>(input_name); 330 if (output_name_type) 331 *output_name_type = internal_name ? &internal_name->name_type : NULL; 332 return GSS_S_COMPLETE; 333 } 334 335 OM_uint32 MockGSSAPILibrary::display_status( 336 OM_uint32* minor_status, 337 OM_uint32 status_value, 338 int status_type, 339 const gss_OID mech_type, 340 OM_uint32* message_context, 341 gss_buffer_t status_string) { 342 if (minor_status) 343 *minor_status = 0; 344 std::string msg = base::StringPrintf("Value: %u, Type %u", 345 status_value, 346 status_type); 347 if (message_context) 348 *message_context = 0; 349 BufferFromString(msg, status_string); 350 return GSS_S_COMPLETE; 351 } 352 353 OM_uint32 MockGSSAPILibrary::init_sec_context( 354 OM_uint32* minor_status, 355 const gss_cred_id_t initiator_cred_handle, 356 gss_ctx_id_t* context_handle, 357 const gss_name_t target_name, 358 const gss_OID mech_type, 359 OM_uint32 req_flags, 360 OM_uint32 time_req, 361 const gss_channel_bindings_t input_chan_bindings, 362 const gss_buffer_t input_token, 363 gss_OID* actual_mech_type, 364 gss_buffer_t output_token, 365 OM_uint32* ret_flags, 366 OM_uint32* time_rec) { 367 if (minor_status) 368 *minor_status = 0; 369 if (!context_handle) 370 return GSS_S_CALL_BAD_STRUCTURE; 371 GssContextMockImpl** internal_context_handle = 372 reinterpret_cast<test::GssContextMockImpl**>(context_handle); 373 // Create it if necessary. 374 if (!*internal_context_handle) { 375 *internal_context_handle = new GssContextMockImpl; 376 } 377 EXPECT_TRUE(*internal_context_handle); 378 GssContextMockImpl& context = **internal_context_handle; 379 if (expected_security_queries_.empty()) { 380 return GSS_S_UNAVAILABLE; 381 } 382 SecurityContextQuery security_query = expected_security_queries_.front(); 383 expected_security_queries_.pop_front(); 384 EXPECT_EQ(std::string("Negotiate"), security_query.expected_package); 385 OM_uint32 major_status = security_query.response_code; 386 if (minor_status) 387 *minor_status = security_query.minor_response_code; 388 context.src_name = security_query.context_info.src_name; 389 context.targ_name = security_query.context_info.targ_name; 390 context.lifetime_rec = security_query.context_info.lifetime_rec; 391 CopyOid(&context.mech_type, &security_query.context_info.mech_type); 392 context.ctx_flags = security_query.context_info.ctx_flags; 393 context.locally_initiated = security_query.context_info.locally_initiated; 394 context.open = security_query.context_info.open; 395 if (!input_token) { 396 EXPECT_FALSE(security_query.expected_input_token.length); 397 } else { 398 EXPECT_EQ(input_token->length, security_query.expected_input_token.length); 399 if (input_token->length) { 400 EXPECT_EQ(0, memcmp(input_token->value, 401 security_query.expected_input_token.value, 402 input_token->length)); 403 } 404 } 405 CopyBuffer(output_token, &security_query.output_token); 406 if (actual_mech_type) 407 CopyOid(*actual_mech_type, mech_type); 408 if (ret_flags) 409 *ret_flags = req_flags; 410 return major_status; 411 } 412 413 OM_uint32 MockGSSAPILibrary::wrap_size_limit( 414 OM_uint32* minor_status, 415 const gss_ctx_id_t context_handle, 416 int conf_req_flag, 417 gss_qop_t qop_req, 418 OM_uint32 req_output_size, 419 OM_uint32* max_input_size) { 420 if (minor_status) 421 *minor_status = 0; 422 ADD_FAILURE(); 423 return GSS_S_UNAVAILABLE; 424 } 425 426 OM_uint32 MockGSSAPILibrary::delete_sec_context( 427 OM_uint32* minor_status, 428 gss_ctx_id_t* context_handle, 429 gss_buffer_t output_token) { 430 if (minor_status) 431 *minor_status = 0; 432 if (!context_handle) 433 return GSS_S_CALL_BAD_STRUCTURE; 434 GssContextMockImpl** internal_context_handle = 435 reinterpret_cast<GssContextMockImpl**>(context_handle); 436 if (*internal_context_handle) { 437 delete *internal_context_handle; 438 *internal_context_handle = NULL; 439 } 440 return GSS_S_COMPLETE; 441 } 442 443 OM_uint32 MockGSSAPILibrary::inquire_context( 444 OM_uint32* minor_status, 445 const gss_ctx_id_t context_handle, 446 gss_name_t* src_name, 447 gss_name_t* targ_name, 448 OM_uint32* lifetime_rec, 449 gss_OID* mech_type, 450 OM_uint32* ctx_flags, 451 int* locally_initiated, 452 int* open) { 453 if (minor_status) 454 *minor_status = 0; 455 if (!context_handle) 456 return GSS_S_CALL_BAD_STRUCTURE; 457 GssContextMockImpl* internal_context_ptr = 458 reinterpret_cast<GssContextMockImpl*>(context_handle); 459 GssContextMockImpl& context = *internal_context_ptr; 460 if (src_name) 461 NameFromString(context.src_name, *src_name); 462 if (targ_name) 463 NameFromString(context.targ_name, *targ_name); 464 if (lifetime_rec) 465 *lifetime_rec = context.lifetime_rec; 466 if (mech_type) 467 CopyOid(*mech_type, &context.mech_type); 468 if (ctx_flags) 469 *ctx_flags = context.ctx_flags; 470 if (locally_initiated) 471 *locally_initiated = context.locally_initiated; 472 if (open) 473 *open = context.open; 474 return GSS_S_COMPLETE; 475 } 476 477 } // namespace test 478 479 } // namespace net 480 481
