10204266204

Committed 01 Aug 2024 07:06PM UTC coverage: 63.165% (-0.006%) from 63.171%

Build # 10204266204

Build Type

Pull #1409

github

Committed by

web-flow

Commit Message

Merge 26df81616 into 6093118ba

Pull Request Pull Request #1409: sync: Send a hash of all database rules at beginning and end of sync

Run Details

5656 of 13490 branches covered (41.93%)

Branch coverage included in aggregate %.

83 of 85 new or added lines in 9 files covered. (97.65%)

13 existing lines in 2 files now uncovered.

18891 of 25372 relevant lines covered (74.46%)

6303.13 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

74.72

/Source/common/SNTRule.mm

/// Copyright 2015 Google Inc. All rights reserved.
///
/// Licensed under the Apache License, Version 2.0 (the "License");
/// you may not use this file except in compliance with the License.
/// You may obtain a copy of the License at
///
///    http://www.apache.org/licenses/LICENSE-2.0
///
///    Unless required by applicable law or agreed to in writing, software
///    distributed under the License is distributed on an "AS IS" BASIS,
///    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
///    See the License for the specific language governing permissions and
///    limitations under the License.

#import "Source/common/SNTRule.h"

#include <CommonCrypto/CommonCrypto.h>
#include <Kernel/kern/cs_blobs.h>
#include <os/base.h>

#import "Source/common/SNTSyncConstants.h"
#import "Source/common/String.h"

// https://developer.apple.com/help/account/manage-your-team/locate-your-team-id/
static const NSUInteger kExpectedTeamIDLength = 10;

@interface SNTRule ()
@property(readwrite) NSUInteger timestamp;
@end

@implementation SNTRule

- (instancetype)initWithIdentifier:(NSString *)identifier
                             state:(SNTRuleState)state
                              type:(SNTRuleType)type
                         customMsg:(NSString *)customMsg
                         timestamp:(NSUInteger)timestamp {
  self = [super init];
  if (self) {
    if (identifier.length == 0) {
      return nil;
    }

    NSCharacterSet *nonHex =
      [[NSCharacterSet characterSetWithCharactersInString:@"0123456789abcdef"] invertedSet];
    NSCharacterSet *nonUppercaseAlphaNumeric = [[NSCharacterSet
      characterSetWithCharactersInString:@"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"] invertedSet];

    switch (type) {
      case SNTRuleTypeBinary: OS_FALLTHROUGH;
      case SNTRuleTypeCertificate: {
        // For binary and certificate rules, force the hash identifier to be lowercase hex.
        identifier = [identifier lowercaseString];

        identifier = [identifier stringByTrimmingCharactersInSet:nonHex];
        if (identifier.length != (CC_SHA256_DIGEST_LENGTH * 2)) {
          return nil;
        }

        break;
      }

      case SNTRuleTypeTeamID: {
        // TeamIDs are always [0-9A-Z], so enforce that the identifier is uppercase
        identifier =
          [[identifier uppercaseString] stringByTrimmingCharactersInSet:nonUppercaseAlphaNumeric];
        if (identifier.length != kExpectedTeamIDLength) {
          return nil;
        }

        break;
      }

      case SNTRuleTypeSigningID: {
        // SigningID rules are a combination of `TeamID:SigningID`. The TeamID should
        // be forced to be uppercase, but because very loose rules exist for SigningIDs,
        // their case will be kept as-is. However, platform binaries are expected to
        // have the hardcoded string "platform" as the team ID and the case will be left
        // as is.
        NSArray *sidComponents = [identifier componentsSeparatedByString:@":"];
        if (!sidComponents || sidComponents.count < 2) {
          return nil;
        }

        // The first component is the TeamID
        NSString *teamID = sidComponents[0];

        if (![teamID isEqualToString:@"platform"]) {
          teamID =
            [[teamID uppercaseString] stringByTrimmingCharactersInSet:nonUppercaseAlphaNumeric];
          if (teamID.length != kExpectedTeamIDLength) {
            return nil;
          }
        }

        // The rest of the components are the Signing ID since ":" a legal character.
        // Join all but the last element of the components to rebuild the SigningID.
        NSString *signingID = [[sidComponents
          subarrayWithRange:NSMakeRange(1, sidComponents.count - 1)] componentsJoinedByString:@":"];
        if (signingID.length == 0) {
          return nil;
        }

        identifier = [NSString stringWithFormat:@"%@:%@", teamID, signingID];
        break;
      }

      case SNTRuleTypeCDHash: {
        identifier = [[identifier lowercaseString] stringByTrimmingCharactersInSet:nonHex];
        if (identifier.length != CS_CDHASH_LEN * 2) {
          return nil;
        }
        break;
      }

      default: {
        break;
      }
    }

    _identifier = identifier;
    _state = state;
    _type = type;
    _customMsg = customMsg;
    _timestamp = timestamp;
  }
  return self;
}

- (instancetype)initWithIdentifier:(NSString *)identifier
                             state:(SNTRuleState)state
                              type:(SNTRuleType)type
                         customMsg:(NSString *)customMsg {
  self = [self initWithIdentifier:identifier state:state type:type customMsg:customMsg timestamp:0];
  // Initialize timestamp to current time if rule is transitive.
  if (self && state == SNTRuleStateAllowTransitive) {
    [self resetTimestamp];
  }
  return self;
}

// Converts rule information downloaded from the server into a SNTRule.  Because any information
// not recorded by SNTRule is thrown away here, this method is also responsible for dealing with
// the extra bundle rule information (bundle_hash & rule_count).
- (instancetype)initWithDictionary:(NSDictionary *)dict {
  if (![dict isKindOfClass:[NSDictionary class]]) return nil;

  NSString *identifier = dict[kRuleIdentifier];
  if (![identifier isKindOfClass:[NSString class]] || !identifier.length) {
    identifier = dict[kRuleSHA256];
  }
  if (![identifier isKindOfClass:[NSString class]] || !identifier.length) return nil;

  NSString *policyString = dict[kRulePolicy];
  SNTRuleState state;
  if (![policyString isKindOfClass:[NSString class]]) return nil;
  if ([policyString isEqual:kRulePolicyAllowlist] ||
      [policyString isEqual:kRulePolicyAllowlistDeprecated]) {
    state = SNTRuleStateAllow;
  } else if ([policyString isEqual:kRulePolicyAllowlistCompiler] ||
             [policyString isEqual:kRulePolicyAllowlistCompilerDeprecated]) {
    state = SNTRuleStateAllowCompiler;
  } else if ([policyString isEqual:kRulePolicyBlocklist] ||
             [policyString isEqual:kRulePolicyBlocklistDeprecated]) {
    state = SNTRuleStateBlock;
  } else if ([policyString isEqual:kRulePolicySilentBlocklist] ||
             [policyString isEqual:kRulePolicySilentBlocklistDeprecated]) {
    state = SNTRuleStateSilentBlock;
  } else if ([policyString isEqual:kRulePolicyRemove]) {
    state = SNTRuleStateRemove;
  } else {
    return nil;
  }

  NSString *ruleTypeString = dict[kRuleType];
  SNTRuleType type;
  if (![ruleTypeString isKindOfClass:[NSString class]]) return nil;
  if ([ruleTypeString isEqual:kRuleTypeBinary]) {
    type = SNTRuleTypeBinary;
  } else if ([ruleTypeString isEqual:kRuleTypeCertificate]) {
    type = SNTRuleTypeCertificate;
  } else if ([ruleTypeString isEqual:kRuleTypeTeamID]) {
    type = SNTRuleTypeTeamID;
  } else if ([ruleTypeString isEqual:kRuleTypeSigningID]) {
    type = SNTRuleTypeSigningID;
  } else if ([ruleTypeString isEqual:kRuleTypeCDHash]) {
    type = SNTRuleTypeCDHash;
  } else {
    return nil;
  }

  NSString *customMsg = dict[kRuleCustomMsg];
  if (![customMsg isKindOfClass:[NSString class]] || customMsg.length == 0) {
    customMsg = nil;
  }

  NSString *customURL = dict[kRuleCustomURL];
  if (![customURL isKindOfClass:[NSString class]] || customURL.length == 0) {
    customURL = nil;
  }

  SNTRule *r = [self initWithIdentifier:identifier state:state type:type customMsg:customMsg];
  r.customURL = customURL;
  return r;
}

#pragma mark NSSecureCoding

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wobjc-literal-conversion"
#define ENCODE(obj, key) \
  if (obj) [coder encodeObject:obj forKey:key]
#define DECODE(cls, key) [decoder decodeObjectOfClass:[cls class] forKey:key]

+ (BOOL)supportsSecureCoding {
  return YES;
}

- (void)encodeWithCoder:(NSCoder *)coder {
  ENCODE(self.identifier, @"identifier");
  ENCODE(@(self.state), @"state");
  ENCODE(@(self.type), @"type");
  ENCODE(self.customMsg, @"custommsg");
  ENCODE(self.customURL, @"customurl");
  ENCODE(@(self.timestamp), @"timestamp");
}

- (instancetype)initWithCoder:(NSCoder *)decoder {
  self = [super init];
  if (self) {
    _identifier = DECODE(NSString, @"identifier");
    _state = (SNTRuleState)[DECODE(NSNumber, @"state") intValue];
    _type = (SNTRuleType)[DECODE(NSNumber, @"type") intValue];
    _customMsg = DECODE(NSString, @"custommsg");
    _customURL = DECODE(NSString, @"customurl");
    _timestamp = [DECODE(NSNumber, @"timestamp") unsignedIntegerValue];
  }
  return self;
}

- (NSString *)ruleStateToPolicyString:(SNTRuleState)state {
  switch (state) {
    case SNTRuleStateAllow: return kRulePolicyAllowlist;
    case SNTRuleStateAllowCompiler: return kRulePolicyAllowlistCompiler;
    case SNTRuleStateBlock: return kRulePolicyBlocklist;
    case SNTRuleStateSilentBlock: return kRulePolicySilentBlocklist;
    case SNTRuleStateRemove: return kRulePolicyRemove;
    case SNTRuleStateAllowTransitive: return @"AllowTransitive";
    // This should never be hit. But is here for completion.
    default: return @"Unknown";
  }
}

- (NSString *)ruleTypeToString:(SNTRuleType)ruleType {
  switch (ruleType) {
    case SNTRuleTypeBinary: return kRuleTypeBinary;
    case SNTRuleTypeCertificate: return kRuleTypeCertificate;
    case SNTRuleTypeTeamID: return kRuleTypeTeamID;
    case SNTRuleTypeSigningID: return kRuleTypeSigningID;
    // This should never be hit. If we have rule types of Unknown then there's a
    // coding error somewhere.
    default: return @"Unknown";
  }
}

// Returns an NSDictionary representation of the rule. Primarily use for
// exporting rules.
- (NSDictionary *)dictionaryRepresentation {
  return @{
    kRuleIdentifier : self.identifier,
    kRulePolicy : [self ruleStateToPolicyString:self.state],
    kRuleType : [self ruleTypeToString:self.type],
    kRuleCustomMsg : self.customMsg ?: @"",
    kRuleCustomURL : self.customURL ?: @""
  };
}

#undef DECODE
#undef ENCODE
#pragma clang diagnostic pop

- (BOOL)isEqual:(id)other {
  if (other == self) return YES;
  if (![other isKindOfClass:[SNTRule class]]) return NO;
  SNTRule *o = other;
  return ([self.identifier isEqual:o.identifier] && self.state == o.state && self.type == o.type);
}

- (NSUInteger)hash {
  NSUInteger prime = 31;
  NSUInteger result = 1;
  result = prime * result + [self.identifier hash];
  result = prime * result + self.state;
  result = prime * result + self.type;
  return result;
}

- (NSString *)description {
  return [NSString
    stringWithFormat:@"SNTRule: Identifier: %@, State: %ld, Type: %ld, Timestamp: %lu",
                     self.identifier, self.state, self.type, (unsigned long)self.timestamp];
}

#pragma mark Last-access Timestamp

- (void)resetTimestamp {
  self.timestamp = (NSUInteger)[[NSDate date] timeIntervalSinceReferenceDate];
}

- (NSString *)digest {
  NSString *ruleDigestFormat = [[NSString alloc]
    initWithFormat:@"%@:%ld:%ld:%lu", self.identifier, self.state, self.type, self.timestamp];
  NSData *ruleData = [ruleDigestFormat dataUsingEncoding:NSUTF8StringEncoding];

  unsigned char digest[CC_SHA256_DIGEST_LENGTH];
  CC_SHA256(ruleData.bytes, (CC_LONG)ruleData.length, (unsigned char *)&digest);

  return santa::SHA256DigestToNSString(digest);
}

@end

1	/// Copyright 2015 Google Inc. All rights reserved.
2	///
3	/// Licensed under the Apache License, Version 2.0 (the "License");
4	/// you may not use this file except in compliance with the License.
5	/// You may obtain a copy of the License at
6	///
7	/// http://www.apache.org/licenses/LICENSE-2.0
8	///
9	/// Unless required by applicable law or agreed to in writing, software
10	/// distributed under the License is distributed on an "AS IS" BASIS,
11	/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	/// See the License for the specific language governing permissions and
13	/// limitations under the License.
14
15	#import "Source/common/SNTRule.h"
16
17	#include <CommonCrypto/CommonCrypto.h>
18	#include <Kernel/kern/cs_blobs.h>
19	#include <os/base.h>
20
21	#import "Source/common/SNTSyncConstants.h"
22	#import "Source/common/String.h"
23
24	// https://developer.apple.com/help/account/manage-your-team/locate-your-team-id/
25	static const NSUInteger kExpectedTeamIDLength = 10;
26
27	@interface SNTRule ()
28	@property(readwrite) NSUInteger timestamp;
29	@end
30
31	@implementation SNTRule
32
33	- (instancetype)initWithIdentifier:(NSString *)identifier
34	state:(SNTRuleState)state
35	type:(SNTRuleType)type
36	customMsg:(NSString *)customMsg
37	timestamp:(NSUInteger)timestamp {	99✔
38	self = [super init];	99✔
39	if (self) {	99!
40	if (identifier.length == 0) {	99!
41	return nil;	×
42	}	×
43
44	NSCharacterSet *nonHex =	99✔
45	[[NSCharacterSet characterSetWithCharactersInString:@"0123456789abcdef"] invertedSet];	99✔
46	NSCharacterSet *nonUppercaseAlphaNumeric = [[NSCharacterSet	99✔
47	characterSetWithCharactersInString:@"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"] invertedSet];	99✔
48
49	switch (type) {	99✔
50	case SNTRuleTypeBinary: OS_FALLTHROUGH;	27✔
51	case SNTRuleTypeCertificate: {	43✔
52	// For binary and certificate rules, force the hash identifier to be lowercase hex.
53	identifier = [identifier lowercaseString];	43✔
54
55	identifier = [identifier stringByTrimmingCharactersInSet:nonHex];	43✔
56	if (identifier.length != (CC_SHA256_DIGEST_LENGTH * 2)) {	43✔
57	return nil;	1✔
58	}	1✔
59
60	break;	42✔
61	}	43✔
62
63	case SNTRuleTypeTeamID: {	42✔
64	// TeamIDs are always [0-9A-Z], so enforce that the identifier is uppercase
65	identifier =	20✔
66	[[identifier uppercaseString] stringByTrimmingCharactersInSet:nonUppercaseAlphaNumeric];	20✔
67	if (identifier.length != kExpectedTeamIDLength) {	20✔
68	return nil;	2✔
69	}	2✔
70
71	break;	18✔
72	}	20✔
73
74	case SNTRuleTypeSigningID: {	26✔
75	// SigningID rules are a combination of `TeamID:SigningID`. The TeamID should
76	// be forced to be uppercase, but because very loose rules exist for SigningIDs,
77	// their case will be kept as-is. However, platform binaries are expected to
78	// have the hardcoded string "platform" as the team ID and the case will be left
79	// as is.
80	NSArray *sidComponents = [identifier componentsSeparatedByString:@":"];	25✔
81	if (!sidComponents \|\| sidComponents.count < 2) {	25!
82	return nil;	×
83	}	×
84
85	// The first component is the TeamID
86	NSString *teamID = sidComponents[0];	25✔
87
88	if (![teamID isEqualToString:@"platform"]) {	25✔
89	teamID =	23✔
90	[[teamID uppercaseString] stringByTrimmingCharactersInSet:nonUppercaseAlphaNumeric];	23✔
91	if (teamID.length != kExpectedTeamIDLength) {	23✔
92	return nil;	3✔
93	}	3✔
94	}	23✔
95
96	// The rest of the components are the Signing ID since ":" a legal character.
97	// Join all but the last element of the components to rebuild the SigningID.
98	NSString *signingID = [[sidComponents	22✔
99	subarrayWithRange:NSMakeRange(1, sidComponents.count - 1)] componentsJoinedByString:@":"];	22✔
100	if (signingID.length == 0) {	22✔
101	return nil;	1✔
102	}	1✔
103
104	identifier = [NSString stringWithFormat:@"%@:%@", teamID, signingID];	21✔
105	break;	21✔
106	}	22✔
107
108	case SNTRuleTypeCDHash: {	11✔
109	identifier = [[identifier lowercaseString] stringByTrimmingCharactersInSet:nonHex];	11✔
110	if (identifier.length != CS_CDHASH_LEN * 2) {	11!
111	return nil;	×
112	}	×
113	break;	11✔
114	}	11✔
115
116	default: {	11!
117	break;	×
118	}	11✔
119	}	99✔
120
121	_identifier = identifier;	92✔
122	_state = state;	92✔
123	_type = type;	92✔
124	_customMsg = customMsg;	92✔
125	_timestamp = timestamp;	92✔
126	}	92✔
127	return self;	92✔
128	}	99✔
129
130	- (instancetype)initWithIdentifier:(NSString *)identifier
131	state:(SNTRuleState)state
132	type:(SNTRuleType)type
133	customMsg:(NSString *)customMsg {	53✔
134	self = [self initWithIdentifier:identifier state:state type:type customMsg:customMsg timestamp:0];	53✔
135	// Initialize timestamp to current time if rule is transitive.
136	if (self && state == SNTRuleStateAllowTransitive) {	53✔
137	[self resetTimestamp];	1✔
138	}	1✔
139	return self;	53✔
140	}	53✔
141
142	// Converts rule information downloaded from the server into a SNTRule. Because any information
143	// not recorded by SNTRule is thrown away here, this method is also responsible for dealing with
144	// the extra bundle rule information (bundle_hash & rule_count).
145	- (instancetype)initWithDictionary:(NSDictionary *)dict {	52✔
146	if (![dict isKindOfClass:[NSDictionary class]]) return nil;	52!
147
148	NSString *identifier = dict[kRuleIdentifier];	52✔
149	if (![identifier isKindOfClass:[NSString class]] \|\| !identifier.length) {	52✔
150	identifier = dict[kRuleSHA256];	3✔
151	}	3✔
152	if (![identifier isKindOfClass:[NSString class]] \|\| !identifier.length) return nil;	52!
153
154	NSString *policyString = dict[kRulePolicy];	50✔
155	SNTRuleState state;	50✔
156	if (![policyString isKindOfClass:[NSString class]]) return nil;	50✔
157	if ([policyString isEqual:kRulePolicyAllowlist] \|\|	49✔
158	[policyString isEqual:kRulePolicyAllowlistDeprecated]) {	49!
159	state = SNTRuleStateAllow;	20✔
160	} else if ([policyString isEqual:kRulePolicyAllowlistCompiler] \|\|	29✔
161	[policyString isEqual:kRulePolicyAllowlistCompilerDeprecated]) {	29!
162	state = SNTRuleStateAllowCompiler;	4✔
163	} else if ([policyString isEqual:kRulePolicyBlocklist] \|\|	25✔
164	[policyString isEqual:kRulePolicyBlocklistDeprecated]) {	25!
165	state = SNTRuleStateBlock;	9✔
166	} else if ([policyString isEqual:kRulePolicySilentBlocklist] \|\|	16✔
167	[policyString isEqual:kRulePolicySilentBlocklistDeprecated]) {	16!
168	state = SNTRuleStateSilentBlock;	6✔
169	} else if ([policyString isEqual:kRulePolicyRemove]) {	15✔
170	state = SNTRuleStateRemove;	9✔
171	} else {	9✔
172	return nil;	1✔
173	}	1✔
174
175	NSString *ruleTypeString = dict[kRuleType];	48✔
176	SNTRuleType type;	48✔
177	if (![ruleTypeString isKindOfClass:[NSString class]]) return nil;	48!
178	if ([ruleTypeString isEqual:kRuleTypeBinary]) {	48✔
179	type = SNTRuleTypeBinary;	13✔
180	} else if ([ruleTypeString isEqual:kRuleTypeCertificate]) {	35✔
181	type = SNTRuleTypeCertificate;	5✔
182	} else if ([ruleTypeString isEqual:kRuleTypeTeamID]) {	30✔
183	type = SNTRuleTypeTeamID;	10✔
184	} else if ([ruleTypeString isEqual:kRuleTypeSigningID]) {	20✔
185	type = SNTRuleTypeSigningID;	15✔
186	} else if ([ruleTypeString isEqual:kRuleTypeCDHash]) {	15✔
187	type = SNTRuleTypeCDHash;	4✔
188	} else {	5✔
189	return nil;	1✔
190	}	1✔
191
192	NSString *customMsg = dict[kRuleCustomMsg];	47✔
193	if (![customMsg isKindOfClass:[NSString class]] \|\| customMsg.length == 0) {	47✔
194	customMsg = nil;	43✔
195	}	43✔
196
197	NSString *customURL = dict[kRuleCustomURL];	47✔
198	if (![customURL isKindOfClass:[NSString class]] \|\| customURL.length == 0) {	47✔
199	customURL = nil;	43✔
200	}	43✔
201
202	SNTRule *r = [self initWithIdentifier:identifier state:state type:type customMsg:customMsg];	47✔
203	r.customURL = customURL;	47✔
204	return r;	47✔
205	}	48✔
206
207	#pragma mark NSSecureCoding
208
209	#pragma clang diagnostic push
210	#pragma clang diagnostic ignored "-Wobjc-literal-conversion"
211	#define ENCODE(obj, key) \
212	if (obj) [coder encodeObject:obj forKey:key]	×
213	#define DECODE(cls, key) [decoder decodeObjectOfClass:[cls class] forKey:key]	×
214
215	+ (BOOL)supportsSecureCoding {	×
216	return YES;	×
217	}	×
218
219	- (void)encodeWithCoder:(NSCoder *)coder {	×
220	ENCODE(self.identifier, @"identifier");	×
221	ENCODE(@(self.state), @"state");	×
222	ENCODE(@(self.type), @"type");	×
223	ENCODE(self.customMsg, @"custommsg");	×
224	ENCODE(self.customURL, @"customurl");	×
225	ENCODE(@(self.timestamp), @"timestamp");	×
226	}	×
227
228	- (instancetype)initWithCoder:(NSCoder *)decoder {	×
229	self = [super init];	×
230	if (self) {	×
231	_identifier = DECODE(NSString, @"identifier");	×
NEW 232	_state = (SNTRuleState)[DECODE(NSNumber, @"state") intValue];	×
NEW 233	_type = (SNTRuleType)[DECODE(NSNumber, @"type") intValue];	×
234	_customMsg = DECODE(NSString, @"custommsg");	×
235	_customURL = DECODE(NSString, @"customurl");	×
236	_timestamp = [DECODE(NSNumber, @"timestamp") unsignedIntegerValue];	×
237	}	×
238	return self;	×
239	}	×
240
241	- (NSString *)ruleStateToPolicyString:(SNTRuleState)state {	7✔
242	switch (state) {	7✔
243	case SNTRuleStateAllow: return kRulePolicyAllowlist;	2✔
244	case SNTRuleStateAllowCompiler: return kRulePolicyAllowlistCompiler;	1✔
245	case SNTRuleStateBlock: return kRulePolicyBlocklist;	2✔
246	case SNTRuleStateSilentBlock: return kRulePolicySilentBlocklist;	1✔
247	case SNTRuleStateRemove: return kRulePolicyRemove;	1✔
248	case SNTRuleStateAllowTransitive: return @"AllowTransitive";	×
249	// This should never be hit. But is here for completion.
250	default: return @"Unknown";	×
251	}	7✔
252	}	7✔
253
254	- (NSString *)ruleTypeToString:(SNTRuleType)ruleType {	7✔
255	switch (ruleType) {	7✔
256	case SNTRuleTypeBinary: return kRuleTypeBinary;	6✔
257	case SNTRuleTypeCertificate: return kRuleTypeCertificate;	×
258	case SNTRuleTypeTeamID: return kRuleTypeTeamID;	1✔
259	case SNTRuleTypeSigningID: return kRuleTypeSigningID;	×
260	// This should never be hit. If we have rule types of Unknown then there's a
261	// coding error somewhere.
262	default: return @"Unknown";	×
263	}	7✔
264	}	7✔
265
266	// Returns an NSDictionary representation of the rule. Primarily use for
267	// exporting rules.
268	- (NSDictionary *)dictionaryRepresentation {	7✔
269	return @{	×
270	kRuleIdentifier : self.identifier,	×
271	kRulePolicy : [self ruleStateToPolicyString:self.state],	×
272	kRuleType : [self ruleTypeToString:self.type],	×
273	kRuleCustomMsg : self.customMsg ?: @"",	✔
274	kRuleCustomURL : self.customURL ?: @""	✔
275	};	×
276	}	1✔
277
278	#undef DECODE
279	#undef ENCODE
280	#pragma clang diagnostic pop
281
282	- (BOOL)isEqual:(id)other {	9✔
283	if (other == self) return YES;	9!
284	if (![other isKindOfClass:[SNTRule class]]) return NO;	9!
285	SNTRule *o = other;	9✔
286	return ([self.identifier isEqual:o.identifier] && self.state == o.state && self.type == o.type);	9!
287	}	9✔
288
289	- (NSUInteger)hash {	×
290	NSUInteger prime = 31;	×
291	NSUInteger result = 1;	×
292	result = prime * result + [self.identifier hash];	×
293	result = prime * result + self.state;	×
294	result = prime * result + self.type;	×
295	return result;	×
296	}	×
297
298	- (NSString *)description {	1✔
299	return [NSString	1✔
300	stringWithFormat:@"SNTRule: Identifier: %@, State: %ld, Type: %ld, Timestamp: %lu",	1✔
301	self.identifier, self.state, self.type, (unsigned long)self.timestamp];	1✔
302	}	1✔
303
304	#pragma mark Last-access Timestamp
305
306	- (void)resetTimestamp {	1✔
307	self.timestamp = (NSUInteger)[[NSDate date] timeIntervalSinceReferenceDate];	1✔
308	}	1✔
309
310	- (NSString *)digest {	8✔
311	NSString *ruleDigestFormat = [[NSString alloc]	8✔
312	initWithFormat:@"%@:%ld:%ld:%lu", self.identifier, self.state, self.type, self.timestamp];	8✔
313	NSData *ruleData = [ruleDigestFormat dataUsingEncoding:NSUTF8StringEncoding];	8✔
314
315	unsigned char digest[CC_SHA256_DIGEST_LENGTH];	8✔
316	CC_SHA256(ruleData.bytes, (CC_LONG)ruleData.length, (unsigned char *)&digest);	8✔
317
318	return santa::SHA256DigestToNSString(digest);	8✔
319	}	8✔
320
321	@end

google / santa / 10204266204

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous