sec/securityd/asynchttp.c

   1 /*
   2  * Copyright (c) 2009-2010 Apple Inc. All Rights Reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23
  24 /*
  25  * asynchttp.c - asynchronous http get/post engine.
  26  */
  27
  28 #include "asynchttp.h"
  29
  30 #include <CoreFoundation/CFNumber.h>
  31 #include <CoreFoundation/CFStream.h>
  32 #include <CFNetwork/CFProxySupport.h>
  33 #include <Security/SecInternal.h>
  34 #include "SecBase64.h"
  35 #include <AssertMacros.h>
  36 #include <utilities/debugging.h>
  37 #include <utilities/SecDispatchRelease.h>
  38 #include <asl.h>
  39 #include <string.h>
  40
  41 #include <inttypes.h>
  42
  43 #if __LP64__
  44 #define PRIstatus "d"
  45 #else
  46 #define PRIstatus "ld"
  47 #endif
  48
  49 #define ocspdErrorLog(args...)     asl_log(NULL, NULL, ASL_LEVEL_ERR, ## args)
  50
  51 /* POST method has Content-Type header line equal to
  52    "application/ocsp-request" */
  53 static CFStringRef kContentType         = CFSTR("Content-Type");
  54 static CFStringRef kAppOcspRequest      = CFSTR("application/ocsp-request");
  55
  56 /* SPI to specify timeout on CFReadStream */
  57 #define _kCFStreamPropertyReadTimeout   CFSTR("_kCFStreamPropertyReadTimeout")
  58 #define _kCFStreamPropertyWriteTimeout   CFSTR("_kCFStreamPropertyWriteTimeout")
  59
  60 /* The timeout we set - 7 seconds */
  61 #define STREAM_TIMEOUT          (7 * NSEC_PER_SEC)
  62
  63 #define POST_BUFSIZE   2048
  64
  65 /* There has got to be an easier way to do this.  For now we based this code
  66    on CFNetwork/Connection/URLResponse.cpp. */
  67 static CFStringRef copyParseMaxAge(CFStringRef cacheControlHeader) {
  68     /* The format of the cache control header is a comma-separated list, but
  69        each list element could be a key-value pair, with the value quoted and
  70        possibly containing a comma. */
  71     CFStringInlineBuffer inlineBuf;
  72     CFRange componentRange;
  73     CFIndex length = CFStringGetLength(cacheControlHeader);
  74     bool done = false;
  75     CFCharacterSetRef whitespaceSet = CFCharacterSetGetPredefined(kCFCharacterSetWhitespace);
  76     CFStringRef maxAgeValue = NULL;
  77
  78     CFStringInitInlineBuffer(cacheControlHeader, &inlineBuf, CFRangeMake(0, length));
  79     componentRange.location = 0;
  80
  81     while (!done) {
  82         bool inQuotes = false;
  83         bool foundComponentStart = false;
  84         CFIndex charIndex = componentRange.location;
  85         CFIndex componentEnd = -1;
  86         CFRange maxAgeRg;
  87         componentRange.length = 0;
  88
  89         while (charIndex < length) {
  90             UniChar ch = CFStringGetCharacterFromInlineBuffer(&inlineBuf, charIndex);
  91             if (!inQuotes && ch == ',') {
  92                 componentRange.length = charIndex - componentRange.location;
  93                 break;
  94             }
  95             if (!CFCharacterSetIsCharacterMember(whitespaceSet, ch)) {
  96                 if (!foundComponentStart) {
  97                     foundComponentStart = true;
  98                     componentRange.location = charIndex;
  99                 } else {
 100                     componentEnd = charIndex;
 101                 }
 102                 if (ch == '\"') {
 103                     inQuotes = (inQuotes == false);
 104                 }
 105             }
 106             charIndex ++;
 107         }
 108
 109         if (componentEnd == -1) {
 110             componentRange.length = charIndex - componentRange.location;
 111         } else {
 112             componentRange.length = componentEnd - componentRange.location + 1;
 113         }
 114
 115         if (charIndex == length) {
 116             /* Fell off the end; this is the last component. */
 117             done = true;
 118         }
 119
 120         /* componentRange should now contain the range of the current
 121            component; trimmed of any whitespace. */
 122
 123         /* We want to look for a max-age value. */
 124         if (!maxAgeValue && CFStringFindWithOptions(cacheControlHeader, CFSTR("max-age"), componentRange, kCFCompareCaseInsensitive | kCFCompareAnchored, &maxAgeRg)) {
 125             CFIndex equalIdx;
 126             CFIndex maxCompRg = componentRange.location + componentRange.length;
 127             for (equalIdx = maxAgeRg.location + maxAgeRg.length; equalIdx < maxCompRg; equalIdx ++) {
 128                 UniChar equalCh = CFStringGetCharacterFromInlineBuffer(&inlineBuf, equalIdx);
 129                 if (equalCh == '=') {
 130                     // Parse out max-age value
 131                     equalIdx ++;
 132                     while (equalIdx < maxCompRg && CFCharacterSetIsCharacterMember(whitespaceSet, CFStringGetCharacterAtIndex(cacheControlHeader, equalIdx))) {
 133                         equalIdx ++;
 134                     }
 135                     if (equalIdx < maxCompRg) {
 136                         maxAgeValue = CFStringCreateWithSubstring(kCFAllocatorDefault, cacheControlHeader, CFRangeMake(equalIdx, maxCompRg-equalIdx));
 137                     }
 138                 } else if (!CFCharacterSetIsCharacterMember(whitespaceSet, equalCh)) {
 139                     // Not a valid max-age header; break out doing nothing
 140                     break;
 141                 }
 142             }
 143         }
 144
 145         if (!done && maxAgeValue) {
 146             done = true;
 147         }
 148         if (!done) {
 149             /* Advance to the next component; + 1 to get past the comma. */
 150             componentRange.location = charIndex + 1;
 151         }
 152     }
 153
 154     return maxAgeValue;
 155 }
 156
 157 static void asynchttp_complete(asynchttp_t *http) {
 158     secdebug("http", "http: %p", http);
 159     /* Shutdown streams and timer, we're about to invoke our client callback. */
 160     if (http->stream) {
 161         CFReadStreamSetClient(http->stream, kCFStreamEventNone, NULL, NULL);
 162         CFReadStreamSetDispatchQueue(http->stream, NULL);
 163         CFReadStreamClose(http->stream);
 164         CFReleaseNull(http->stream);
 165     }
 166     if (http->timer) {
 167         dispatch_source_cancel(http->timer);
 168         dispatch_release_null(http->timer);
 169     }
 170
 171     if (http->completed) {
 172         /* This should probably move to our clients. */
 173         CFTimeInterval maxAge = NULL_TIME;
 174         if (http->response) {
 175             CFStringRef cacheControl = CFHTTPMessageCopyHeaderFieldValue(
 176                 http->response, CFSTR("cache-control"));
 177             if (cacheControl) {
 178                 CFStringRef maxAgeValue = copyParseMaxAge(cacheControl);
 179                 CFRelease(cacheControl);
 180                 if (maxAgeValue) {
 181                     secdebug("http", "http header max-age: %@", maxAgeValue);
 182                     maxAge = CFStringGetDoubleValue(maxAgeValue);
 183                     CFRelease(maxAgeValue);
 184                 }
 185             }
 186         }
 187         http->completed(http, maxAge);
 188     }
 189 }
 190
 191 static void handle_server_response(CFReadStreamRef stream,
 192     CFStreamEventType type, void *info) {
 193     asynchttp_t *http = (asynchttp_t *)info;
 194     if (!http->stream) {
 195         secerror("Avoiding crash due to CFReadStream invoking us after we called CFReadStreamSetDispatchQueue(stream, NULL) on a different block on our serial queue");
 196         return;
 197     }
 198
 199     switch (type) {
 200     case kCFStreamEventHasBytesAvailable:
 201     {
 202         UInt8 buffer[POST_BUFSIZE];
 203         CFIndex length;
 204         do {
 205 #if 1
 206             length = CFReadStreamRead(stream, buffer, sizeof(buffer));
 207 #else
 208             const UInt8 *buffer = CFReadStreamGetBuffer(stream, -1, &length);
 209 #endif
 210             secdebug("http",
 211                 "stream: %@ kCFStreamEventHasBytesAvailable read: %lu bytes",
 212                 stream, length);
 213             if (length < 0) {
 214                 /* Negative length == error */
 215                 asynchttp_complete(http);
 216                 break;
 217             } else if (length > 0) {
 218                 //CFHTTPMessageAppendBytes(http->response, buffer, length);
 219                 CFDataAppendBytes(http->data, buffer, length);
 220             } else {
 221                 /* Read 0 bytes, are we are done or do we wait for
 222                    kCFStreamEventEndEncountered? */
 223                 asynchttp_complete(http);
 224                 break;
 225             }
 226         } while (CFReadStreamHasBytesAvailable(stream));
 227         break;
 228     }
 229     case kCFStreamEventErrorOccurred:
 230     {
 231         CFStreamError error = CFReadStreamGetError(stream);
 232
 233         secdebug("http",
 234             "stream: %@ kCFStreamEventErrorOccurred domain: %ld error: %ld",
 235             stream, error.domain, (long) error.error);
 236
 237         if (error.domain == kCFStreamErrorDomainPOSIX) {
 238             ocspdErrorLog("CFReadStream posix: %s", strerror(error.error));
 239         } else if (error.domain == kCFStreamErrorDomainMacOSStatus) {
 240             ocspdErrorLog("CFReadStream osstatus: %"PRIstatus, error.error);
 241         } else {
 242             ocspdErrorLog("CFReadStream domain: %ld error: %"PRIstatus,
 243                 error.domain, error.error);
 244         }
 245         asynchttp_complete(http);
 246         break;
 247     }
 248     case kCFStreamEventEndEncountered:
 249     {
 250         http->response = (CFHTTPMessageRef)CFReadStreamCopyProperty(
 251             stream, kCFStreamPropertyHTTPResponseHeader);
 252         secdebug("http", "stream: %@ kCFStreamEventEndEncountered hdr: %@",
 253             stream, http->response);
 254         CFHTTPMessageSetBody(http->response, http->data);
 255         asynchttp_complete(http);
 256         break;
 257     }
 258     default:
 259         ocspdErrorLog("handle_server_response unexpected event type: %lu",
 260             type);
 261         break;
 262     }
 263 }
 264
 265 /* Create a URI suitable for use in an http GET request, will return NULL if
 266    the length would exceed 255 bytes. */
 267 static CFURLRef createGetURL(CFURLRef responder, CFDataRef request) {
 268     CFURLRef getURL = NULL;
 269     CFMutableDataRef base64Request = NULL;
 270     CFStringRef base64RequestString = NULL;
 271     CFStringRef peRequest = NULL;
 272     CFIndex base64Len;
 273
 274     base64Len = SecBase64Encode(NULL, CFDataGetLength(request), NULL, 0);
 275     /* Don't bother doing all the work below if we know the end result will
 276        exceed 255 bytes (minus one for the '/' separator makes 254). */
 277     if (base64Len + CFURLGetBytes(responder, NULL, 0) > 254)
 278         return NULL;
 279
 280     require(base64Request = CFDataCreateMutable(kCFAllocatorDefault,
 281         base64Len), errOut);
 282     CFDataSetLength(base64Request, base64Len);
 283     SecBase64Encode(CFDataGetBytePtr(request), CFDataGetLength(request),
 284         (char *)CFDataGetMutableBytePtr(base64Request), base64Len);
 285     require(base64RequestString = CFStringCreateWithBytes(kCFAllocatorDefault,
 286         CFDataGetBytePtr(base64Request), base64Len, kCFStringEncodingUTF8,
 287         false), errOut);
 288     require(peRequest = CFURLCreateStringByAddingPercentEscapes(
 289         kCFAllocatorDefault, base64RequestString, NULL, CFSTR("+/="),
 290         kCFStringEncodingUTF8), errOut);
 291 #if 1
 292     CFStringRef urlString = CFURLGetString(responder);
 293     CFStringRef fullURL;
 294     if (CFStringHasSuffix(urlString, CFSTR("/"))) {
 295         fullURL = CFStringCreateWithFormat(kCFAllocatorDefault, NULL,
 296             CFSTR("%@%@"), urlString, peRequest);
 297     } else {
 298         fullURL = CFStringCreateWithFormat(kCFAllocatorDefault, NULL,
 299             CFSTR("%@/%@"), urlString, peRequest);
 300     }
 301     getURL = CFURLCreateWithString(kCFAllocatorDefault, fullURL, NULL);
 302     CFRelease(fullURL);
 303 #else
 304     getURL = CFURLCreateWithString(kCFAllocatorDefault, peRequest, responder);
 305 #endif
 306
 307 errOut:
 308     CFReleaseSafe(base64Request);
 309     CFReleaseSafe(base64RequestString);
 310     CFReleaseSafe(peRequest);
 311
 312     return getURL;
 313 }
 314
 315 bool asyncHttpPost(CFURLRef responder, CFDataRef requestData /* , bool force_nocache */ ,
 316     asynchttp_t *http) {
 317     bool result = true; /* True, we didn't schedule any work. */
 318         /* resources to release on exit */
 319     CFURLRef getURL = NULL;
 320
 321 /* Interesting tidbit from rfc5019
 322    When sending requests that are less than or equal to 255 bytes in
 323    total (after encoding) including the scheme and delimiters (http://),
 324    server name and base64-encoded OCSPRequest structure, clients MUST
 325    use the GET method (to enable OCSP response caching).  OCSP requests
 326    larger than 255 bytes SHOULD be submitted using the POST method.
 327
 328    Interesting tidbit from rfc2616:
 329    Note: Servers ought to be cautious about depending on URI lengths
 330    above 255 bytes, because some older client or proxy
 331    implementations might not properly support these lengths.
 332
 333    Given the second note I'm assuming that the note in rfc5019 is about the
 334    length of the URI, not the length of the entire HTTP request.
 335
 336    If we need to consider the entire request we need to have 17 bytes less, or
 337    17 + 25 = 42 if we are appending a "Cache-Control: no-cache CRLF" header
 338    field.
 339
 340    The 17 and 42 above are based on the request encoding from rfc2616
 341    Method SP Request-URI SP HTTP-Version CRLF (header CRLF)* CRLF
 342    so in our case it's:
 343    GET SP URI SP HTTP/1.1 CRLF CRLF
 344    17 + len(URI) bytes
 345    or
 346    GET SP URI SP HTTP/1.1 CRLF Cache-Control: SP no-cache CRLF CRLF
 347    42 + len(URI) bytes
 348  */
 349
 350     /* First let's try creating a GET request. */
 351     getURL = createGetURL(responder, requestData);
 352     if (getURL && CFURLGetBytes(getURL, NULL, 0) < 256) {
 353         /* Get URI is less than 256 bytes encoded, making it safe even for
 354            older proxy or caching servers, so let's use HTTP GET. */
 355         secdebug("http", "GET[%ld] %@", CFURLGetBytes(getURL, NULL, 0), getURL);
 356         require_quiet(http->request = CFHTTPMessageCreateRequest(kCFAllocatorDefault,
 357             CFSTR("GET"), getURL, kCFHTTPVersion1_1), errOut);
 358     } else {
 359         /* GET Request too big to ensure error free transmission, let's
 360            create a HTTP POST http->request instead. */
 361         secdebug("http", "POST %@ CRLF body", responder);
 362         require_quiet(http->request = CFHTTPMessageCreateRequest(kCFAllocatorDefault,
 363             CFSTR("POST"), responder, kCFHTTPVersion1_1), errOut);
 364         /* Set the body and required header fields. */
 365         CFHTTPMessageSetBody(http->request, requestData);
 366         CFHTTPMessageSetHeaderFieldValue(http->request, kContentType,
 367             kAppOcspRequest);
 368     }
 369
 370 #if 0
 371     if (force_nocache) {
 372         CFHTTPMessageSetHeaderFieldValue(http->request, CFSTR("Cache-Control"),
 373             CFSTR("no-cache"));
 374     }
 375 #endif
 376
 377     result = asynchttp_request(NULL, http);
 378
 379 errOut:
 380     CFReleaseSafe(getURL);
 381
 382     return result;
 383 }
 384
 385
 386 static void asynchttp_timer_proc(asynchttp_t *http) {
 387     CFStringRef req_meth = http->request ? CFHTTPMessageCopyRequestMethod(http->request) : NULL;
 388     CFURLRef req_url = http->request ? CFHTTPMessageCopyRequestURL(http->request) : NULL;
 389     secnotice("http", "Timeout during %@ %@.", req_meth, req_url);
 390     CFReleaseSafe(req_url);
 391     CFReleaseSafe(req_meth);
 392     asynchttp_complete(http);
 393 }
 394
 395
 396 void asynchttp_free(asynchttp_t *http) {
 397     if (http) {
 398         CFReleaseNull(http->request);
 399         CFReleaseNull(http->response);
 400         CFReleaseNull(http->data);
 401         CFReleaseNull(http->stream);
 402         dispatch_release_null(http->timer);
 403     }
 404 }
 405
 406 /* Return true, iff we didn't schedule any work, return false if we did. */
 407 bool asynchttp_request(CFHTTPMessageRef request, asynchttp_t *http) {
 408     secdebug("http", "request %@", request);
 409     if (request) {
 410         http->request = request;
 411         CFRetain(request);
 412     }
 413
 414     /* Create the stream for the request. */
 415     require_quiet(http->stream = CFReadStreamCreateForHTTPRequest(
 416         kCFAllocatorDefault, http->request), errOut);
 417
 418         /* Set a reasonable timeout */
 419     require_quiet(http->timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, http->queue), errOut);
 420     dispatch_source_set_event_handler(http->timer, ^{
 421         asynchttp_timer_proc(http);
 422     });
 423     // Set the timer's fire time to now + STREAM_TIMEOUT seconds with a .5 second fuzz factor.
 424     dispatch_source_set_timer(http->timer, dispatch_time(DISPATCH_TIME_NOW, STREAM_TIMEOUT),
 425                               DISPATCH_TIME_FOREVER, (int64_t)(500 * NSEC_PER_MSEC));
 426     dispatch_resume(http->timer);
 427
 428         /* Set up possible proxy info */
 429         CFDictionaryRef proxyDict = CFNetworkCopySystemProxySettings();
 430         if (proxyDict) {
 431                 CFReadStreamSetProperty(http->stream, kCFStreamPropertyHTTPProxy, proxyDict);
 432         CFRelease(proxyDict);
 433     }
 434
 435     http->data = CFDataCreateMutable(kCFAllocatorDefault, 0);
 436
 437     CFStreamClientContext stream_context = { .info = http };
 438     CFReadStreamSetClient(http->stream,
 439         (kCFStreamEventHasBytesAvailable
 440          | kCFStreamEventErrorOccurred
 441          | kCFStreamEventEndEncountered),
 442         handle_server_response, &stream_context);
 443     CFReadStreamSetDispatchQueue(http->stream, http->queue);
 444     CFReadStreamOpen(http->stream);
 445
 446     return false; /* false -> something was scheduled. */
 447
 448 errOut:
 449     /* Deschedule timer and free anything we might have retained so far. */
 450     asynchttp_free(http);
 451     return true;
 452 }