The Tor Browser / file comparison

comparison: extensions/auth/nsAuthSSPI.cpp

extensions/auth/nsAuthSSPI.cpp

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:576eea4e5dc6
1 /* vim:set ts=4 sw=4 sts=4 et cindent: */
2 /* This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5
6 //
7 // Negotiate Authentication Support Module
8 //
9 // Described by IETF Internet draft: draft-brezak-kerberos-http-00.txt
10 // (formerly draft-brezak-spnego-http-04.txt)
11 //
12 // Also described here:
13 // http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnsecure/html/http-sso-1.asp
14 //
15
16 #include "nsAuthSSPI.h"
17 #include "nsIServiceManager.h"
18 #include "nsIDNSService.h"
19 #include "nsIDNSRecord.h"
20 #include "nsNetCID.h"
21 #include "nsCOMPtr.h"
22 #include "nsICryptoHash.h"
23 #include "mozilla/Telemetry.h"
24
25 #include <windows.h>
26
27 #define SEC_SUCCESS(Status) ((Status) >= 0)
28
29 #ifndef KERB_WRAP_NO_ENCRYPT
30 #define KERB_WRAP_NO_ENCRYPT 0x80000001
31 #endif
32
33 #ifndef SECBUFFER_PADDING
34 #define SECBUFFER_PADDING 9
35 #endif
36
37 #ifndef SECBUFFER_STREAM
38 #define SECBUFFER_STREAM 10
39 #endif
40
41 //-----------------------------------------------------------------------------
42
43 static const wchar_t *const pTypeName [] = {
44 L"Kerberos",
45 L"Negotiate",
46 L"NTLM"
47 };
48
49 #ifdef DEBUG
50 #define CASE_(_x) case _x: return # _x;
51 static const char *MapErrorCode(int rc)
52 {
53 switch (rc) {
54 CASE_(SEC_E_OK)
55 CASE_(SEC_I_CONTINUE_NEEDED)
56 CASE_(SEC_I_COMPLETE_NEEDED)
57 CASE_(SEC_I_COMPLETE_AND_CONTINUE)
58 CASE_(SEC_E_INCOMPLETE_MESSAGE)
59 CASE_(SEC_I_INCOMPLETE_CREDENTIALS)
60 CASE_(SEC_E_INVALID_HANDLE)
61 CASE_(SEC_E_TARGET_UNKNOWN)
62 CASE_(SEC_E_LOGON_DENIED)
63 CASE_(SEC_E_INTERNAL_ERROR)
64 CASE_(SEC_E_NO_CREDENTIALS)
65 CASE_(SEC_E_NO_AUTHENTICATING_AUTHORITY)
66 CASE_(SEC_E_INSUFFICIENT_MEMORY)
67 CASE_(SEC_E_INVALID_TOKEN)
68 }
69 return "<unknown>";
70 }
71 #else
72 #define MapErrorCode(_rc) ""
73 #endif
74
75 //-----------------------------------------------------------------------------
76
77 static PSecurityFunctionTableW sspi;
78
79 static nsresult
80 InitSSPI()
81 {
82 LOG((" InitSSPI\n"));
83
84 sspi = InitSecurityInterfaceW();
85 if (!sspi) {
86 LOG(("InitSecurityInterfaceW failed"));
87 return NS_ERROR_UNEXPECTED;
88 }
89
90 return NS_OK;
91 }
92
93 //-----------------------------------------------------------------------------
94
95 static nsresult
96 MakeSN(const char *principal, nsCString &result)
97 {
98 nsresult rv;
99
100 nsAutoCString buf(principal);
101
102 // The service name looks like "protocol@hostname", we need to map
103 // this to a value that SSPI expects. To be consistent with IE, we
104 // need to map '@' to '/' and canonicalize the hostname.
105 int32_t index = buf.FindChar('@');
106 if (index == kNotFound)
107 return NS_ERROR_UNEXPECTED;
108
109 nsCOMPtr<nsIDNSService> dns = do_GetService(NS_DNSSERVICE_CONTRACTID, &rv);
110 if (NS_FAILED(rv))
111 return rv;
112
113 // This could be expensive if our DNS cache cannot satisfy the request.
114 // However, we should have at least hit the OS resolver once prior to
115 // reaching this code, so provided the OS resolver has this information
116 // cached, we should not have to worry about blocking on this function call
117 // for very long. NOTE: because we ask for the canonical hostname, we
118 // might end up requiring extra network activity in cases where the OS
119 // resolver might not have enough information to satisfy the request from
120 // its cache. This is not an issue in versions of Windows up to WinXP.
121 nsCOMPtr<nsIDNSRecord> record;
122 rv = dns->Resolve(Substring(buf, index + 1),
123 nsIDNSService::RESOLVE_CANONICAL_NAME,
124 getter_AddRefs(record));
125 if (NS_FAILED(rv))
126 return rv;
127
128 nsAutoCString cname;
129 rv = record->GetCanonicalName(cname);
130 if (NS_SUCCEEDED(rv)) {
131 result = StringHead(buf, index) + NS_LITERAL_CSTRING("/") + cname;
132 LOG(("Using SPN of [%s]\n", result.get()));
133 }
134 return rv;
135 }
136
137 //-----------------------------------------------------------------------------
138
139 nsAuthSSPI::nsAuthSSPI(pType package)
140 : mServiceFlags(REQ_DEFAULT)
141 , mMaxTokenLen(0)
142 , mPackage(package)
143 , mCertDERData(nullptr)
144 , mCertDERLength(0)
145 {
146 memset(&mCred, 0, sizeof(mCred));
147 memset(&mCtxt, 0, sizeof(mCtxt));
148 }
149
150 nsAuthSSPI::~nsAuthSSPI()
151 {
152 Reset();
153
154 if (mCred.dwLower || mCred.dwUpper) {
155 #ifdef __MINGW32__
156 (sspi->FreeCredentialsHandle)(&mCred);
157 #else
158 (sspi->FreeCredentialHandle)(&mCred);
159 #endif
160 memset(&mCred, 0, sizeof(mCred));
161 }
162 }
163
164 void
165 nsAuthSSPI::Reset()
166 {
167 mIsFirst = true;
168
169 if (mCertDERData){
170 nsMemory::Free(mCertDERData);
171 mCertDERData = nullptr;
172 mCertDERLength = 0;
173 }
174
175 if (mCtxt.dwLower || mCtxt.dwUpper) {
176 (sspi->DeleteSecurityContext)(&mCtxt);
177 memset(&mCtxt, 0, sizeof(mCtxt));
178 }
179 }
180
181 NS_IMPL_ISUPPORTS(nsAuthSSPI, nsIAuthModule)
182
183 NS_IMETHODIMP
184 nsAuthSSPI::Init(const char *serviceName,
185 uint32_t serviceFlags,
186 const char16_t *domain,
187 const char16_t *username,
188 const char16_t *password)
189 {
190 LOG((" nsAuthSSPI::Init\n"));
191
192 mIsFirst = true;
193 mCertDERLength = 0;
194 mCertDERData = nullptr;
195
196 // The caller must supply a service name to be used. (For why we now require
197 // a service name for NTLM, see bug 487872.)
198 NS_ENSURE_TRUE(serviceName && *serviceName, NS_ERROR_INVALID_ARG);
199
200 nsresult rv;
201
202 // XXX lazy initialization like this assumes that we are single threaded
203 if (!sspi) {
204 rv = InitSSPI();
205 if (NS_FAILED(rv))
206 return rv;
207 }
208 SEC_WCHAR *package;
209
210 package = (SEC_WCHAR *) pTypeName[(int)mPackage];
211
212 if (mPackage == PACKAGE_TYPE_NTLM) {
213 // (bug 535193) For NTLM, just use the uri host, do not do canonical host lookups.
214 // The incoming serviceName is in the format: "protocol@hostname", SSPI expects
215 // "<service class>/<hostname>", so swap the '@' for a '/'.
216 mServiceName.Assign(serviceName);
217 int32_t index = mServiceName.FindChar('@');
218 if (index == kNotFound)
219 return NS_ERROR_UNEXPECTED;
220 mServiceName.Replace(index, 1, '/');
221 }
222 else {
223 // Kerberos requires the canonical host, MakeSN takes care of this through a
224 // DNS lookup.
225 rv = MakeSN(serviceName, mServiceName);
226 if (NS_FAILED(rv))
227 return rv;
228 }
229
230 mServiceFlags = serviceFlags;
231
232 SECURITY_STATUS rc;
233
234 PSecPkgInfoW pinfo;
235 rc = (sspi->QuerySecurityPackageInfoW)(package, &pinfo);
236 if (rc != SEC_E_OK) {
237 LOG(("%s package not found\n", package));
238 return NS_ERROR_UNEXPECTED;
239 }
240 mMaxTokenLen = pinfo->cbMaxToken;
241 (sspi->FreeContextBuffer)(pinfo);
242
243 MS_TimeStamp useBefore;
244
245 SEC_WINNT_AUTH_IDENTITY_W ai;
246 SEC_WINNT_AUTH_IDENTITY_W *pai = nullptr;
247
248 // domain, username, and password will be null if nsHttpNTLMAuth's ChallengeReceived
249 // returns false for identityInvalid. Use default credentials in this case by passing
250 // null for pai.
251 if (username && password) {
252 // Keep a copy of these strings for the duration
253 mUsername.Assign(username);
254 mPassword.Assign(password);
255 mDomain.Assign(domain);
256 ai.Domain = reinterpret_cast<unsigned short*>(mDomain.BeginWriting());
257 ai.DomainLength = mDomain.Length();
258 ai.User = reinterpret_cast<unsigned short*>(mUsername.BeginWriting());
259 ai.UserLength = mUsername.Length();
260 ai.Password = reinterpret_cast<unsigned short*>(mPassword.BeginWriting());
261 ai.PasswordLength = mPassword.Length();
262 ai.Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
263 pai = &ai;
264 }
265
266 rc = (sspi->AcquireCredentialsHandleW)(nullptr,
267 package,
268 SECPKG_CRED_OUTBOUND,
269 nullptr,
270 pai,
271 nullptr,
272 nullptr,
273 &mCred,
274 &useBefore);
275 if (rc != SEC_E_OK)
276 return NS_ERROR_UNEXPECTED;
277
278 static bool sTelemetrySent = false;
279 if (!sTelemetrySent) {
280 mozilla::Telemetry::Accumulate(
281 mozilla::Telemetry::NTLM_MODULE_USED_2,
282 serviceFlags & nsIAuthModule::REQ_PROXY_AUTH
283 ? NTLM_MODULE_WIN_API_PROXY
284 : NTLM_MODULE_WIN_API_DIRECT);
285 sTelemetrySent = true;
286 }
287
288 LOG(("AcquireCredentialsHandle() succeeded.\n"));
289 return NS_OK;
290 }
291
292 // The arguments inToken and inTokenLen are used to pass in the server
293 // certificate (when available) in the first call of the function. The
294 // second time these arguments hold an input token.
295 NS_IMETHODIMP
296 nsAuthSSPI::GetNextToken(const void *inToken,
297 uint32_t inTokenLen,
298 void **outToken,
299 uint32_t *outTokenLen)
300 {
301 // String for end-point bindings.
302 const char end_point[] = "tls-server-end-point:";
303 const int end_point_length = sizeof(end_point) - 1;
304 const int hash_size = 32; // Size of a SHA256 hash.
305 const int cbt_size = hash_size + end_point_length;
306
307 SECURITY_STATUS rc;
308 MS_TimeStamp ignored;
309
310 DWORD ctxAttr, ctxReq = 0;
311 CtxtHandle *ctxIn;
312 SecBufferDesc ibd, obd;
313 // Optional second input buffer for the CBT (Channel Binding Token)
314 SecBuffer ib[2], ob;
315 // Pointer to the block of memory that stores the CBT
316 char* sspi_cbt = nullptr;
317 SEC_CHANNEL_BINDINGS pendpoint_binding;
318
319 LOG(("entering nsAuthSSPI::GetNextToken()\n"));
320
321 if (!mCred.dwLower && !mCred.dwUpper) {
322 LOG(("nsAuthSSPI::GetNextToken(), not initialized. exiting."));
323 return NS_ERROR_NOT_INITIALIZED;
324 }
325
326 if (mServiceFlags & REQ_DELEGATE)
327 ctxReq |= ISC_REQ_DELEGATE;
328 if (mServiceFlags & REQ_MUTUAL_AUTH)
329 ctxReq |= ISC_REQ_MUTUAL_AUTH;
330
331 if (inToken) {
332 if (mIsFirst) {
333 // First time if it comes with a token,
334 // the token represents the server certificate.
335 mIsFirst = false;
336 mCertDERLength = inTokenLen;
337 mCertDERData = nsMemory::Alloc(inTokenLen);
338 if (!mCertDERData)
339 return NS_ERROR_OUT_OF_MEMORY;
340 memcpy(mCertDERData, inToken, inTokenLen);
341
342 // We are starting a new authentication sequence.
343 // If we have already initialized our
344 // security context, then we're in trouble because it means that the
345 // first sequence failed. We need to bail or else we might end up in
346 // an infinite loop.
347 if (mCtxt.dwLower || mCtxt.dwUpper) {
348 LOG(("Cannot restart authentication sequence!"));
349 return NS_ERROR_UNEXPECTED;
350 }
351 ctxIn = nullptr;
352 // The certificate needs to be erased before being passed
353 // to InitializeSecurityContextW().
354 inToken = nullptr;
355 inTokenLen = 0;
356 } else {
357 ibd.ulVersion = SECBUFFER_VERSION;
358 ibd.cBuffers = 0;
359 ibd.pBuffers = ib;
360
361 // If we have stored a certificate, the Channel Binding Token
362 // needs to be generated and sent in the first input buffer.
363 if (mCertDERLength > 0) {
364 // First we create a proper Endpoint Binding structure.
365 pendpoint_binding.dwInitiatorAddrType = 0;
366 pendpoint_binding.cbInitiatorLength = 0;
367 pendpoint_binding.dwInitiatorOffset = 0;
368 pendpoint_binding.dwAcceptorAddrType = 0;
369 pendpoint_binding.cbAcceptorLength = 0;
370 pendpoint_binding.dwAcceptorOffset = 0;
371 pendpoint_binding.cbApplicationDataLength = cbt_size;
372 pendpoint_binding.dwApplicationDataOffset =
373 sizeof(SEC_CHANNEL_BINDINGS);
374
375 // Then add it to the array of sec buffers accordingly.
376 ib[ibd.cBuffers].BufferType = SECBUFFER_CHANNEL_BINDINGS;
377 ib[ibd.cBuffers].cbBuffer =
378 pendpoint_binding.cbApplicationDataLength
379 + pendpoint_binding.dwApplicationDataOffset;
380
381 sspi_cbt = (char *) nsMemory::Alloc(ib[ibd.cBuffers].cbBuffer);
382 if (!sspi_cbt){
383 return NS_ERROR_OUT_OF_MEMORY;
384 }
385
386 // Helper to write in the memory block that stores the CBT
387 char* sspi_cbt_ptr = sspi_cbt;
388
389 ib[ibd.cBuffers].pvBuffer = sspi_cbt;
390 ibd.cBuffers++;
391
392 memcpy(sspi_cbt_ptr, &pendpoint_binding,
393 pendpoint_binding.dwApplicationDataOffset);
394 sspi_cbt_ptr += pendpoint_binding.dwApplicationDataOffset;
395
396 memcpy(sspi_cbt_ptr, end_point, end_point_length);
397 sspi_cbt_ptr += end_point_length;
398
399 // Start hashing. We are always doing SHA256, but depending
400 // on the certificate, a different alogirthm might be needed.
401 nsAutoCString hashString;
402
403 nsresult rv;
404 nsCOMPtr<nsICryptoHash> crypto;
405 crypto = do_CreateInstance(NS_CRYPTO_HASH_CONTRACTID, &rv);
406 if (NS_SUCCEEDED(rv))
407 rv = crypto->Init(nsICryptoHash::SHA256);
408 if (NS_SUCCEEDED(rv))
409 rv = crypto->Update((unsigned char*)mCertDERData, mCertDERLength);
410 if (NS_SUCCEEDED(rv))
411 rv = crypto->Finish(false, hashString);
412 if (NS_FAILED(rv)) {
413 nsMemory::Free(mCertDERData);
414 mCertDERData = nullptr;
415 mCertDERLength = 0;
416 nsMemory::Free(sspi_cbt);
417 return rv;
418 }
419
420 // Once the hash has been computed, we store it in memory right
421 // after the Endpoint structure and the "tls-server-end-point:"
422 // char array.
423 memcpy(sspi_cbt_ptr, hashString.get(), hash_size);
424
425 // Free memory used to store the server certificate
426 nsMemory::Free(mCertDERData);
427 mCertDERData = nullptr;
428 mCertDERLength = 0;
429 } // End of CBT computation.
430
431 // We always need this SECBUFFER.
432 ib[ibd.cBuffers].BufferType = SECBUFFER_TOKEN;
433 ib[ibd.cBuffers].cbBuffer = inTokenLen;
434 ib[ibd.cBuffers].pvBuffer = (void *) inToken;
435 ibd.cBuffers++;
436 ctxIn = &mCtxt;
437 }
438 } else { // First time and without a token (no server certificate)
439 // We are starting a new authentication sequence. If we have already
440 // initialized our security context, then we're in trouble because it
441 // means that the first sequence failed. We need to bail or else we
442 // might end up in an infinite loop.
443 if (mCtxt.dwLower || mCtxt.dwUpper || mCertDERData || mCertDERLength) {
444 LOG(("Cannot restart authentication sequence!"));
445 return NS_ERROR_UNEXPECTED;
446 }
447 ctxIn = nullptr;
448 mIsFirst = false;
449 }
450
451 obd.ulVersion = SECBUFFER_VERSION;
452 obd.cBuffers = 1;
453 obd.pBuffers = &ob;
454 ob.BufferType = SECBUFFER_TOKEN;
455 ob.cbBuffer = mMaxTokenLen;
456 ob.pvBuffer = nsMemory::Alloc(ob.cbBuffer);
457 if (!ob.pvBuffer){
458 if (sspi_cbt)
459 nsMemory::Free(sspi_cbt);
460 return NS_ERROR_OUT_OF_MEMORY;
461 }
462 memset(ob.pvBuffer, 0, ob.cbBuffer);
463
464 NS_ConvertUTF8toUTF16 wSN(mServiceName);
465 SEC_WCHAR *sn = (SEC_WCHAR *) wSN.get();
466
467 rc = (sspi->InitializeSecurityContextW)(&mCred,
468 ctxIn,
469 sn,
470 ctxReq,
471 0,
472 SECURITY_NATIVE_DREP,
473 inToken ? &ibd : nullptr,
474 0,
475 &mCtxt,
476 &obd,
477 &ctxAttr,
478 &ignored);
479 if (rc == SEC_I_CONTINUE_NEEDED || rc == SEC_E_OK) {
480
481 #ifdef PR_LOGGING
482 if (rc == SEC_E_OK)
483 LOG(("InitializeSecurityContext: succeeded.\n"));
484 else
485 LOG(("InitializeSecurityContext: continue.\n"));
486 #endif
487 if (sspi_cbt)
488 nsMemory::Free(sspi_cbt);
489
490 if (!ob.cbBuffer) {
491 nsMemory::Free(ob.pvBuffer);
492 ob.pvBuffer = nullptr;
493 }
494 *outToken = ob.pvBuffer;
495 *outTokenLen = ob.cbBuffer;
496
497 if (rc == SEC_E_OK)
498 return NS_SUCCESS_AUTH_FINISHED;
499
500 return NS_OK;
501 }
502
503 LOG(("InitializeSecurityContext failed [rc=%d:%s]\n", rc, MapErrorCode(rc)));
504 Reset();
505 nsMemory::Free(ob.pvBuffer);
506 return NS_ERROR_FAILURE;
507 }
508
509 NS_IMETHODIMP
510 nsAuthSSPI::Unwrap(const void *inToken,
511 uint32_t inTokenLen,
512 void **outToken,
513 uint32_t *outTokenLen)
514 {
515 SECURITY_STATUS rc;
516 SecBufferDesc ibd;
517 SecBuffer ib[2];
518
519 ibd.cBuffers = 2;
520 ibd.pBuffers = ib;
521 ibd.ulVersion = SECBUFFER_VERSION;
522
523 // SSPI Buf
524 ib[0].BufferType = SECBUFFER_STREAM;
525 ib[0].cbBuffer = inTokenLen;
526 ib[0].pvBuffer = nsMemory::Alloc(ib[0].cbBuffer);
527 if (!ib[0].pvBuffer)
528 return NS_ERROR_OUT_OF_MEMORY;
529
530 memcpy(ib[0].pvBuffer, inToken, inTokenLen);
531
532 // app data
533 ib[1].BufferType = SECBUFFER_DATA;
534 ib[1].cbBuffer = 0;
535 ib[1].pvBuffer = nullptr;
536
537 rc = (sspi->DecryptMessage)(
538 &mCtxt,
539 &ibd,
540 0, // no sequence numbers
541 nullptr
542 );
543
544 if (SEC_SUCCESS(rc)) {
545 // check if ib[1].pvBuffer is really just ib[0].pvBuffer, in which
546 // case we can let the caller free it. Otherwise, we need to
547 // clone it, and free the original
548 if (ib[0].pvBuffer == ib[1].pvBuffer) {
549 *outToken = ib[1].pvBuffer;
550 }
551 else {
552 *outToken = nsMemory::Clone(ib[1].pvBuffer, ib[1].cbBuffer);
553 nsMemory::Free(ib[0].pvBuffer);
554 if (!*outToken)
555 return NS_ERROR_OUT_OF_MEMORY;
556 }
557 *outTokenLen = ib[1].cbBuffer;
558 }
559 else
560 nsMemory::Free(ib[0].pvBuffer);
561
562 if (!SEC_SUCCESS(rc))
563 return NS_ERROR_FAILURE;
564
565 return NS_OK;
566 }
567
568 // utility class used to free memory on exit
569 class secBuffers
570 {
571 public:
572
573 SecBuffer ib[3];
574
575 secBuffers() { memset(&ib, 0, sizeof(ib)); }
576
577 ~secBuffers()
578 {
579 if (ib[0].pvBuffer)
580 nsMemory::Free(ib[0].pvBuffer);
581
582 if (ib[1].pvBuffer)
583 nsMemory::Free(ib[1].pvBuffer);
584
585 if (ib[2].pvBuffer)
586 nsMemory::Free(ib[2].pvBuffer);
587 }
588 };
589
590 NS_IMETHODIMP
591 nsAuthSSPI::Wrap(const void *inToken,
592 uint32_t inTokenLen,
593 bool confidential,
594 void **outToken,
595 uint32_t *outTokenLen)
596 {
597 SECURITY_STATUS rc;
598
599 SecBufferDesc ibd;
600 secBuffers bufs;
601 SecPkgContext_Sizes sizes;
602
603 rc = (sspi->QueryContextAttributesW)(
604 &mCtxt,
605 SECPKG_ATTR_SIZES,
606 &sizes);
607
608 if (!SEC_SUCCESS(rc))
609 return NS_ERROR_FAILURE;
610
611 ibd.cBuffers = 3;
612 ibd.pBuffers = bufs.ib;
613 ibd.ulVersion = SECBUFFER_VERSION;
614
615 // SSPI
616 bufs.ib[0].cbBuffer = sizes.cbSecurityTrailer;
617 bufs.ib[0].BufferType = SECBUFFER_TOKEN;
618 bufs.ib[0].pvBuffer = nsMemory::Alloc(sizes.cbSecurityTrailer);
619
620 if (!bufs.ib[0].pvBuffer)
621 return NS_ERROR_OUT_OF_MEMORY;
622
623 // APP Data
624 bufs.ib[1].BufferType = SECBUFFER_DATA;
625 bufs.ib[1].pvBuffer = nsMemory::Alloc(inTokenLen);
626 bufs.ib[1].cbBuffer = inTokenLen;
627
628 if (!bufs.ib[1].pvBuffer)
629 return NS_ERROR_OUT_OF_MEMORY;
630
631 memcpy(bufs.ib[1].pvBuffer, inToken, inTokenLen);
632
633 // SSPI
634 bufs.ib[2].BufferType = SECBUFFER_PADDING;
635 bufs.ib[2].cbBuffer = sizes.cbBlockSize;
636 bufs.ib[2].pvBuffer = nsMemory::Alloc(bufs.ib[2].cbBuffer);
637
638 if (!bufs.ib[2].pvBuffer)
639 return NS_ERROR_OUT_OF_MEMORY;
640
641 rc = (sspi->EncryptMessage)(&mCtxt,
642 confidential ? 0 : KERB_WRAP_NO_ENCRYPT,
643 &ibd, 0);
644
645 if (SEC_SUCCESS(rc)) {
646 int len = bufs.ib[0].cbBuffer + bufs.ib[1].cbBuffer + bufs.ib[2].cbBuffer;
647 char *p = (char *) nsMemory::Alloc(len);
648
649 if (!p)
650 return NS_ERROR_OUT_OF_MEMORY;
651
652 *outToken = (void *) p;
653 *outTokenLen = len;
654
655 memcpy(p, bufs.ib[0].pvBuffer, bufs.ib[0].cbBuffer);
656 p += bufs.ib[0].cbBuffer;
657
658 memcpy(p,bufs.ib[1].pvBuffer, bufs.ib[1].cbBuffer);
659 p += bufs.ib[1].cbBuffer;
660
661 memcpy(p,bufs.ib[2].pvBuffer, bufs.ib[2].cbBuffer);
662
663 return NS_OK;
664 }
665
666 return NS_ERROR_FAILURE;
667 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial