SecurityTool/macOS/trusted_cert_ssl.m

   1 /*
   2  * Copyright (c) 2019 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  * verify_ssl.m
  24  */
  25
  26
  27 #import "trusted_cert_ssl.h"
  28 #include <Foundation/Foundation.h>
  29 #include <CoreServices/CoreServices.h>
  30 #include <Network/Network.h>
  31
  32 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
  33
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37
  38 #if TARGET_OS_MAC
  39 #include <Security/oidscert.h>
  40 #include <Security/oidsattr.h>
  41 #include <Security/oidsalg.h>
  42 #include <Security/x509defs.h>
  43 #include <Security/cssmapi.h>
  44 #include <Security/cssmapple.h>
  45 #endif
  46
  47 #include <Security/certextensions.h>
  48 #include <Security/SecKeychain.h>
  49 #include <Security/SecKeychainItem.h>
  50 #include <Security/SecImportExport.h>
  51 #include <Security/SecIdentity.h>
  52 #include <Security/SecIdentitySearch.h>
  53 #include <Security/SecKey.h>
  54 #include <Security/SecCertificate.h>
  55 #include <Security/SecTrust.h>
  56 #include <Security/SecProtocolOptions.h>
  57
  58 #include <SecurityFoundation/SFCertificateData.h>
  59
  60 #include <nw/private.h>
  61
  62
  63 @interface TLSConnection : NSObject
  64
  65 @property NSURL *url;
  66 @property NSError *error;
  67 @property SecTrustRef trust;
  68 @property BOOL finished;
  69 @property BOOL udp; // default is NO (use tcp)
  70 @property int verbose;
  71 @property dispatch_queue_t queue;
  72 @property nw_connection_t connection;
  73
  74 - (id)initWithURLString:(const char *)urlstr verbose:(int)level;
  75 - (void)dealloc;
  76 - (nw_connection_t)createConnection;
  77 - (void)startConnection;
  78 - (void)waitForConnection;
  79 - (NSError*)error;
  80 - (SecTrustRef)trust;
  81
  82 + (BOOL)isNetworkURL:(const char *)urlstr;
  83
  84 @end
  85
  86 #define ANSI_RED     "\x1b[31m"
  87 #define ANSI_GREEN   "\x1b[32m"
  88 #define ANSI_YELLOW  "\x1b[33m"
  89 #define ANSI_BLUE    "\x1b[34m"
  90 #define ANSI_MAGENTA "\x1b[35m"
  91 #define ANSI_CYAN    "\x1b[36m"
  92 #define ANSI_RESET   "\x1b[0m"
  93
  94 #if OBJC_ARC_DISABLED
  95 #define NW_RETAIN(obj) nw_retain(obj)
  96 #define NW_RELEASE(obj) nw_release(obj)
  97 #define SEC_RELEASE(obj) sec_release(obj)
  98 #define OBJ_RELEASE(obj) [obj release]
  99 #define SUPER_DEALLOC [super dealloc]
 100 #else
 101 #define NW_RETAIN(obj)
 102 #define NW_RELEASE(obj)
 103 #define SEC_RELEASE(obj)
 104 #define OBJ_RELEASE(obj)
 105 #define SUPER_DEALLOC
 106 #endif
 107
 108 @implementation TLSConnection
 109
 110 - (id)initWithURLString:(const char *)urlstr verbose:(int)level
 111 {
 112     if ((self = [super init])) {
 113         _url = [[NSURL alloc] initWithString:[NSString stringWithFormat:@"%s", urlstr]];
 114         _udp = NO;
 115         _finished = NO;
 116         _verbose = level;
 117         _error = nil;
 118         _trust = NULL;
 119         _queue = dispatch_get_main_queue();
 120         _connection = [self createConnection];
 121     }
 122
 123     return self;
 124 }
 125
 126 - (void)dealloc
 127 {
 128     if (_connection) {
 129         NW_RELEASE(_connection);
 130         _connection = NULL;
 131     }
 132     if (_error) {
 133         OBJ_RELEASE(_error);
 134         _error = nil;
 135     }
 136     if (_url) {
 137         OBJ_RELEASE(_url);
 138         _url = nil;
 139     }
 140     if (_trust) {
 141         CFRelease(_trust);
 142         _trust = NULL;
 143     }
 144     SUPER_DEALLOC;
 145 }
 146
 147 - (nw_connection_t)createConnection
 148 {
 149     const char *host = [[self.url host] UTF8String];
 150     const char *port = [[[self.url port] stringValue] UTF8String];
 151     if (!host) {
 152         if (_verbose > 0) { fprintf(stderr, "Unable to continue without a hostname (is URL valid?)\n"); }
 153         self.finished = YES;
 154         return NULL;
 155     }
 156     nw_endpoint_t endpoint = nw_endpoint_create_host(host, (port) ? port : "443");
 157     nw_parameters_configure_protocol_block_t configure_tls = ^(nw_protocol_options_t _Nonnull options) {
 158         sec_protocol_options_t sec_options = nw_tls_copy_sec_protocol_options(options);
 159         sec_protocol_options_set_verify_block(sec_options, ^(
 160             sec_protocol_metadata_t _Nonnull metadata, sec_trust_t _Nonnull trust_ref, sec_protocol_verify_complete_t _Nonnull complete) {
 161             SecTrustRef trust = sec_trust_copy_ref(trust_ref);
 162             if (trust) {
 163                 CFRetain(trust);
 164                 if (self.trust) { CFRelease(self.trust); }
 165                 self.trust = trust;
 166             }
 167             CFErrorRef error = NULL;
 168             BOOL allow = SecTrustEvaluateWithError(trust, &error);
 169             if (error) {
 170                 if (self.error) { OBJ_RELEASE(self.error); }
 171                 self.error = (__bridge NSError *)error;
 172             }
 173             complete(allow);
 174         }, self.queue);
 175     };
 176     nw_parameters_t parameters = nw_parameters_create_secure_tcp(configure_tls, NW_PARAMETERS_DEFAULT_CONFIGURATION);
 177     nw_parameters_set_indefinite(parameters, false); // so we don't enter the 'waiting' state on TLS failure
 178     nw_connection_t connection = nw_connection_create(endpoint, parameters);
 179     NW_RELEASE(endpoint);
 180     NW_RELEASE(parameters);
 181     return connection;
 182 }
 183
 184 - (void)startConnection
 185 {
 186     nw_connection_set_queue(_connection, _queue);
 187     NW_RETAIN(_connection); // Hold a reference until cancelled
 188
 189     nw_connection_set_state_changed_handler(_connection, ^(nw_connection_state_t state, nw_error_t error) {
 190         nw_endpoint_t remote = nw_connection_copy_endpoint(self.connection);
 191         errno = error ? nw_error_get_error_code(error) : 0;
 192         const char *protocol = self.udp ? "udp" : "tcp";
 193         const char *host = nw_endpoint_get_hostname(remote);
 194         uint16_t port = nw_endpoint_get_port(remote);
 195         // note: this code does not handle or expect nw_connection_state_waiting,
 196         // since the connection parameters specified a definite connection.
 197         if (state == nw_connection_state_failed) {
 198             if (self.verbose > 0) {
 199                 fprintf(stderr, "connection to %s port %u (%s) failed\n", host, port, protocol);
 200             }
 201             // Cancel the connection, so we go to nw_connection_state_cancelled
 202             nw_connection_cancel(self.connection);
 203
 204         } else if (state == nw_connection_state_ready) {
 205             if (self.verbose > 0) {
 206                 fprintf(stderr, "connection to %s port %u (%s) opened\n", host, port, protocol);
 207             }
 208             // Once we get the SecTrustRef, we can cancel the connection
 209             nw_connection_cancel(self.connection);
 210
 211         } else if (state == nw_connection_state_cancelled) {
 212             if (self.verbose > 0) {
 213                 fprintf(stderr, "connection to %s port %u (%s) closed\n", host, port, protocol);
 214             }
 215             nw_connection_cancel(self.connection); // cancel to be safe (should be a no-op)
 216             NW_RELEASE(_connection); // release the reference and set flag to exit loop
 217             self.finished = YES;
 218         }
 219         NW_RELEASE(remote);
 220     });
 221
 222     nw_connection_start(_connection);
 223 }
 224
 225 - (void)waitForConnection
 226 {
 227     while (_finished == NO) {
 228         NSDate *cycleTime = [NSDate dateWithTimeIntervalSinceNow:0.1];
 229         [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:cycleTime];
 230     }
 231 }
 232
 233 + (BOOL)isNetworkURL:(const char *)urlstr
 234 {
 235     if (urlstr) {
 236         NSArray *schemes = @[@"https",@"ldaps"];
 237         NSURL *url = [NSURL URLWithString:[NSString stringWithUTF8String:urlstr]];
 238         if (url && [schemes containsObject:[url scheme]]) {
 239             return YES;
 240         }
 241     }
 242     return NO;
 243 }
 244
 245 @end
 246
 247 static NSString *errorStringForKey(NSString *key)
 248 {
 249     NSString *errstr = nil;
 250     // %%% note: these dictionary keys currently do not have exported constants
 251     if (![key length] || [key isEqualToString:@"StatusCodes"]) {
 252         return errstr; // skip empty and legacy numeric errors
 253     } else if ([key isEqualToString:@"SSLHostname"]) {
 254         errstr = @"Host name not found in Subject Alternative Name extension";
 255     } else if ([key isEqualToString:@"TemporalValidity"]) {
 256         errstr = @"Certificate has expired, or is not yet valid (check date)";
 257     } else if ([key isEqualToString:@"KeySize"]) {
 258         errstr = @"Certificate uses a key size which is considered too weak";
 259     } else if ([key isEqualToString:@"SignatureHashAlgorithms"]) {
 260         errstr = @"Certificate uses a signing algorithm which is considered too weak";
 261     } else if ([key isEqualToString:@"KeyUsage"]) {
 262         errstr = @"The Key Usage extension does not permit this use for the certificate";
 263     } else if ([key isEqualToString:@"ExtendedKeyUsage"]) {
 264         errstr = @"The Extended Key Usage extension does not permit this use for the certificate";
 265     } else if ([key isEqualToString:@"Revocation"]) {
 266         errstr = @"Certificate has been revoked and cannot be used";
 267     } else if ([key isEqualToString:@"BlackListedLeaf"]) {
 268         errstr = @"Certificate has been blocked and cannot be used";
 269     } else if ([key isEqualToString:@"AnchorTrusted"]) {
 270         errstr = @"The root of the certificate chain is not trusted";
 271     } else if ([key isEqualToString:@"MissingIntermediate"]) {
 272         errstr = @"Unable to find next certificate in the chain";
 273     } else if ([key isEqualToString:@"NonEmptySubject"]) {
 274         errstr = @"Certificate has no subject, and SAN is missing or not marked critical";
 275     } else if ([key isEqualToString:@"BasicCertificateProcessing"]) {
 276         errstr = @"Certificate not standards compliant (RFC 5280|CABF Baseline Requirements)";
 277     } else if ([key isEqualToString:@"NameConstraints"]) {
 278         errstr = @"Certificate violates name constraints placed on issuing CA";
 279     } else if ([key isEqualToString:@"PolicyConstraints"]) {
 280         errstr = @"Certificate violates policy constraints placed on issuing CA";
 281     } else if ([key isEqualToString:@"CTRequired"]) {
 282         errstr = @"Certificate Transparency validation is required but missing";
 283     } else if ([key isEqualToString:@"ValidityPeriodMaximums"]) {
 284         errstr = @"Certificate exceeds maximum allowable validity period (normally 825 days)";
 285     } else if ([key isEqualToString:@"ServerAuthEKU"]) {
 286         errstr = @"The Extended Key Usage extension does not permit server authentication";
 287     } else if ([key isEqualToString:@"UnparseableExtension"]) {
 288         errstr = @"Unable to parse a standard extension (corrupt or invalid format detected)";
 289     }
 290
 291     if (errstr) {
 292         errstr = [NSString stringWithFormat:@"%@ [%@]", errstr, key];
 293     } else {
 294         errstr = [NSString stringWithFormat:@"[%@]", key];
 295     }
 296     return errstr;
 297 }
 298
 299 void printErrorDetails(SecTrustRef trust)
 300 {
 301     CFDictionaryRef result = SecTrustCopyResult(trust);
 302     CFArrayRef properties = SecTrustCopyProperties(trust);
 303     NSArray *props = (__bridge NSArray *)properties;
 304     NSArray *details = [(__bridge NSDictionary *)result objectForKey:@"TrustResultDetails"];
 305     if (!props || !details) {
 306         if (result) { CFRelease(result); }
 307         if (properties) { CFRelease(properties); }
 308         return;
 309     }
 310     // Preflight to see if there are any errors to display
 311     CFIndex errorCount = 0, chainLength = [details count];
 312     for (CFIndex chainIndex = 0; chainIndex < chainLength; chainIndex++) {
 313         NSDictionary *certDetails = (NSDictionary *)[details objectAtIndex:chainIndex];
 314         errorCount += [certDetails count];
 315     }
 316     if (!errorCount) {
 317         if (result) { CFRelease(result); }
 318         if (properties) { CFRelease(properties); }
 319         return;
 320     }
 321
 322     // Display per-certificate errors
 323     fprintf(stdout, "---\nCertificate errors\n");
 324     for (CFIndex chainIndex = 0; chainIndex < chainLength; chainIndex++) {
 325         NSDictionary *certProps = (NSDictionary *)[props objectAtIndex:chainIndex];
 326         NSString *certTitle = (NSString *)[certProps objectForKey:(__bridge NSString*)kSecPropertyTypeTitle];
 327         fprintf(stdout, " %ld: %s\n", (long)chainIndex, [certTitle UTF8String]);
 328         NSDictionary *certDetails = (NSDictionary *)[details objectAtIndex:chainIndex];
 329         NSEnumerator *keyEnumerator = [certDetails keyEnumerator];
 330         NSString *key;
 331         while ((key = (NSString*)[keyEnumerator nextObject])) {
 332             NSString *str = errorStringForKey(key);
 333             if (!str) { continue; }
 334             fprintf(stdout, ANSI_RED "    %s" ANSI_RESET "\n", [str UTF8String]);
 335         }
 336     }
 337     fflush(stdout);
 338
 339     CFRelease(result);
 340     CFRelease(properties);
 341 }
 342
 343 void printExtendedResults(SecTrustRef trust)
 344 {
 345     CFDictionaryRef trustResults = SecTrustCopyResult(trust);
 346     if (!trustResults) { return; }
 347     fprintf(stdout, "---\n");
 348
 349     NSDictionary *results = (__bridge NSDictionary *)trustResults;
 350     NSString *orgName = [results objectForKey:(NSString *)kSecTrustOrganizationName];
 351     CFBooleanRef isEV = (__bridge CFBooleanRef)[results objectForKey:(NSString *)kSecTrustExtendedValidation];
 352     if (isEV == kCFBooleanTrue) {
 353         fprintf(stdout, "Extended Validation (EV) confirmed for \"" ANSI_GREEN "%s" ANSI_RESET "\"\n", [orgName UTF8String]);
 354     } else {
 355         fprintf(stdout, "No extended validation result found\n");
 356     }
 357     CFBooleanRef isCT = (__bridge CFBooleanRef)[results objectForKey:(NSString *)kSecTrustCertificateTransparency];
 358     CFBooleanRef isCTW = (__bridge CFBooleanRef)[results objectForKey:(NSString *)kSecTrustCertificateTransparencyWhiteList];
 359     if (isCT == kCFBooleanTrue) {
 360         fprintf(stdout, "Certificate Transparency (CT) status: " ANSI_GREEN "verified" ANSI_RESET "\n");
 361     } else if (isCTW == kCFBooleanTrue) {
 362         fprintf(stdout, "Certificate Transparency requirement waived for approved EV certificate\n");
 363     } else {
 364         fprintf(stdout, "Certificate Transparency (CT) status: " ANSI_RED "not verified" ANSI_RESET "\n");
 365         fprintf(stdout, "Unable to find at least 2 signed certificate timestamps (SCTs) from approved logs\n");
 366     }
 367     fflush(stdout);
 368     CFRelease(trustResults);
 369 }
 370
 371 int evaluate_ssl(const char *urlstr, int verbose, SecTrustRef * CF_RETURNS_RETAINED trustRef)
 372 {
 373     @autoreleasepool {
 374         if (trustRef) {
 375             *trustRef = NULL;
 376         }
 377         if (![TLSConnection isNetworkURL:urlstr]) {
 378             return 2;
 379         }
 380         TLSConnection *tls = [[TLSConnection alloc] initWithURLString:urlstr verbose:verbose];
 381         [tls startConnection];
 382         [tls waitForConnection];
 383
 384         NSError *error = [tls error];
 385         if (verbose && error) {
 386             fprintf(stderr, "NSError: { ");
 387             CFShow((__bridge CFErrorRef)error);
 388             fprintf(stderr,"}\n");
 389         }
 390
 391         SecTrustRef trust = [tls trust];
 392         if (trustRef && trust) {
 393             CFRetain(trust);
 394             *trustRef = trust;
 395         }
 396         OBJ_RELEASE(tls);
 397         tls = nil;
 398     }
 399     return 0;
 400 }
 401
 402 static bool isHex(unichar c)
 403 {
 404     return ((c >= 0x30 && c <= 0x39) || /* 0..9 */
 405             (c >= 0x41 && c <= 0x46) || /* A..F */
 406             (c >= 0x61 && c <= 0x66));  /* a..f */
 407 }
 408
 409 static bool isEOL(unichar c)
 410 {
 411     return (c == 0x0D || c == 0x0A);
 412 }
 413
 414 CF_RETURNS_RETAINED CFStringRef CopyCertificateTextRepresentation(SecCertificateRef certificate)
 415 {
 416     if (!certificate) {
 417         return NULL;
 418     }
 419     @autoreleasepool {
 420         NSData *certData = [[[SFCertificateData alloc] initWithCertificate:certificate] tabDelimitedTextData];
 421         NSString *certStr = [[NSString alloc] initWithData:certData encoding:NSUnicodeStringEncoding];
 422         NSMutableString *outStr = [NSMutableString stringWithCapacity:0];
 423         [outStr appendString:certStr];
 424
 425         // process the output for readability by changing tabs to spaces
 426         CFIndex index, count = [outStr length];
 427         for (index = 1; index < count; index++) {
 428             unichar c = [outStr characterAtIndex:index];
 429             unichar p = [outStr characterAtIndex:index-1];
 430             if (isEOL(p)) { // start of line
 431                 while (c == 0x09) { // convert tabs to spaces until non-tab found
 432                     [outStr replaceCharactersInRange:NSMakeRange(index, 1) withString:@" "];
 433                     c = [outStr characterAtIndex:++index];
 434                 }
 435             } else if (c == 0x09) { // tab found between label and value
 436                 if (p == 0x20) { // continue the run of spaces
 437                     [outStr replaceCharactersInRange:NSMakeRange(index, 1) withString:@" "];
 438                 } else { // insert colon delimiter and space
 439                     [outStr replaceCharactersInRange:NSMakeRange(index, 1) withString:@": "];
 440                     count++; // we inserted an extra character
 441                 }
 442             }
 443         }
 444         // remove spaces in hexadecimal data representations for compactness
 445         count = [outStr length];
 446         index = 0;
 447         while (++index < count) {
 448             unichar c = [outStr characterAtIndex:index];
 449             unichar p = [outStr characterAtIndex:index-1];
 450             // possible start of hex data run occurs after colon delimiter
 451             if (p == 0x3A && c == 0x20) {
 452                 CFIndex start = index;
 453                 CFIndex len = 0;
 454                 while ((start+len+3 < count)) {
 455                     // scan for repeating three-character pattern
 456                     unichar first = [outStr characterAtIndex:start+len+0];
 457                     if (first != 0x20) {
 458                         break;
 459                     }
 460                     unichar second = [outStr characterAtIndex:start+len+1];
 461                     unichar third = [outStr characterAtIndex:start+len+2];
 462                     unichar last = [outStr characterAtIndex:start+len+3];
 463                     if (isHex(second) && isHex(third)) {
 464                         len += 3;
 465                     } else if (isEOL(second) && isHex(third) && isHex(last)) {
 466                         len += 4; // pattern continues on next line
 467                     } else {
 468                         break;
 469                     }
 470                 }
 471                 if (len > 0) {
 472                     // skip over the first space after the colon, which we want to keep
 473                     for (CFIndex idx = start+1; idx < count && idx < start+len; idx++) {
 474                         c = [outStr characterAtIndex:idx];
 475                         if (c == 0x20 || isEOL(c)) {
 476                             [outStr deleteCharactersInRange:NSMakeRange(idx,1)];
 477                             count--; // we removed a character from the total length
 478                             len--; // our substring also has one less character
 479                         }
 480                     }
 481                 }
 482             }
 483         }
 484         return CFBridgingRetain(outStr);
 485     }
 486 }
 487