9262563702

Committed 28 May 2024 02:21AM UTC coverage: 62.534% (-0.1%) from 62.648%

Build # 9262563702

Build Type

Pull #1359

github

Committed by

web-flow

Commit Message

Merge 2fc1475c4 into 7502bc247

Pull Request Pull Request #1359: sync: Add a protobuf for the existing sync protocol

Run Details

5283 of 12790 branches covered (41.31%)

Branch coverage included in aggregate %.

241 of 288 new or added lines in 5 files covered. (83.68%)

6 existing lines in 1 file now uncovered.

17807 of 24134 relevant lines covered (73.78%)

6984.95 hits per line

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

75.64

/Source/santasyncservice/SNTSyncEventUpload.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/santasyncservice/SNTSyncEventUpload.h"
#include <Foundation/Foundation.h>

#import <MOLCertificate/MOLCertificate.h>
#import <MOLXPCConnection/MOLXPCConnection.h>

#import "Source/common/SNTCommonEnums.h"
#import "Source/common/SNTConfigurator.h"
#import "Source/common/SNTFileInfo.h"
#import "Source/common/SNTLogging.h"
#import "Source/common/SNTStoredEvent.h"
#import "Source/common/SNTSyncConstants.h"
#import "Source/common/SNTXPCControlInterface.h"
#import "Source/common/String.h"
#import "Source/santasyncservice/NSData+Zlib.h"
#import "Source/santasyncservice/SNTSyncLogging.h"
#import "Source/santasyncservice/SNTSyncState.h"

#include <google/protobuf/arena.h>
#include "Source/santasyncservice/syncv1.pb.h"
namespace pbv1 = ::santa::sync::v1;

using santa::common::NSStringToUTF8String;

@implementation SNTSyncEventUpload

- (NSURL *)stageURL {
  NSString *stageName = [@"eventupload" stringByAppendingFormat:@"/%@", self.syncState.machineID];
  return [NSURL URLWithString:stageName relativeToURL:self.syncState.syncBaseURL];
}

- (BOOL)sync {
  dispatch_semaphore_t sema = dispatch_semaphore_create(0);
  [[self.daemonConn remoteObjectProxy] databaseEventsPending:^(NSArray *events) {
    if (events.count) {
      [self uploadEvents:events];
    }
    dispatch_semaphore_signal(sema);
  }];
  return (dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER) == 0);
}

- (BOOL)uploadEvents:(NSArray *)events {
  google::protobuf::Arena arena;
  auto req = google::protobuf::Arena::Create<::pbv1::EventUploadRequest>(&arena);
  auto uploadEvents = req->mutable_events();

  NSMutableSet *eventIds = [NSMutableSet setWithCapacity:events.count];
  for (SNTStoredEvent *event in events) {
    uploadEvents->Add([self messageForEvent:event]);
    if (event.idx) [eventIds addObject:event.idx];
    if (uploadEvents->size() >= self.syncState.eventBatchSize) break;
  }

  if (self.syncState.syncType == SNTSyncTypeNormal ||
      [[SNTConfigurator configurator] enableCleanSyncEventUpload]) {
    NSDictionary *r = [self performRequest:[self requestWithMessage:req]];
    if (!r) return NO;

    // A list of bundle hashes that require their related binary events to be uploaded.
    self.syncState.bundleBinaryRequests = r[kEventUploadBundleBinaries];

    SLOGI(@"Uploaded %d events", uploadEvents->size());
  }

  // Remove event IDs. For Bundle Events the ID is 0 so nothing happens.
  [[self.daemonConn remoteObjectProxy] databaseRemoveEventsWithIDs:[eventIds allObjects]];

  // See if there are any events remaining to upload
  if (uploadEvents->size() < events.count) {
    NSRange nextEventsRange =
      NSMakeRange(uploadEvents->size(), events.count - uploadEvents->size());
    NSArray *nextEvents = [events subarrayWithRange:nextEventsRange];
    return [self uploadEvents:nextEvents];
  }

  return YES;
}

- (::pbv1::Event)messageForEvent:(SNTStoredEvent *)event {
  google::protobuf::Arena arena;
  ::pbv1::Event *e = google::protobuf::Arena::Create<::pbv1::Event>(&arena);

  e->set_file_sha256(NSStringToUTF8String(event.fileSHA256));
  e->set_file_path(NSStringToUTF8String([event.filePath stringByDeletingLastPathComponent]));
  e->set_file_name(NSStringToUTF8String([event.filePath lastPathComponent]));
  e->set_executing_user(NSStringToUTF8String(event.executingUser));
  e->set_execution_time([event.occurrenceDate timeIntervalSince1970]);

  for (NSString *user in event.loggedInUsers) {
    e->add_logged_in_users(NSStringToUTF8String(user));
  }
  for (NSString *session in event.currentSessions) {
    e->add_current_sessions(NSStringToUTF8String(session));
  }

  switch (event.decision) {
    case SNTEventStateAllowUnknown: e->set_decision(::pbv1::ALLOW_UNKNOWN); break;
    case SNTEventStateAllowBinary: e->set_decision(::pbv1::ALLOW_BINARY); break;
    case SNTEventStateAllowCertificate:
      e->set_decision(::pbv1::ALLOW_CERTIFICATE);
      break;
      break;
    case SNTEventStateAllowScope: e->set_decision(::pbv1::ALLOW_SCOPE); break;
    case SNTEventStateAllowTeamID: e->set_decision(::pbv1::ALLOW_TEAMID); break;
    case SNTEventStateAllowSigningID: e->set_decision(::pbv1::ALLOW_SIGNINGID); break;
    case SNTEventStateAllowCDHash: e->set_decision(::pbv1::ALLOW_CDHASH); break;
    case SNTEventStateBlockUnknown: e->set_decision(::pbv1::BLOCK_UNKNOWN); break;
    case SNTEventStateBlockBinary: e->set_decision(::pbv1::BLOCK_BINARY); break;
    case SNTEventStateBlockCertificate: e->set_decision(::pbv1::BLOCK_CERTIFICATE); break;
    case SNTEventStateBlockScope: e->set_decision(::pbv1::BLOCK_SCOPE); break;
    case SNTEventStateBlockTeamID: e->set_decision(::pbv1::BLOCK_TEAMID); break;
    case SNTEventStateBlockSigningID: e->set_decision(::pbv1::BLOCK_SIGNINGID); break;
    case SNTEventStateBlockCDHash: e->set_decision(::pbv1::BLOCK_CDHASH); break;
    case SNTEventStateBundleBinary:
      e->set_decision(::pbv1::BUNDLE_BINARY);
      e->clear_execution_time();
      break;
    default: e->set_decision(::pbv1::DECISION_UNKNOWN);
  }

  e->set_file_bundle_id(NSStringToUTF8String(event.fileBundleID));
  e->set_file_bundle_path(NSStringToUTF8String(event.fileBundlePath));
  e->set_file_bundle_executable_rel_path(NSStringToUTF8String(event.fileBundleExecutableRelPath));
  e->set_file_bundle_name(NSStringToUTF8String(event.fileBundleName));
  e->set_file_bundle_version(NSStringToUTF8String(event.fileBundleVersion));
  e->set_file_bundle_version_string(NSStringToUTF8String(event.fileBundleVersionString));
  e->set_file_bundle_hash(NSStringToUTF8String(event.fileBundleHash));
  e->set_file_bundle_hash_millis([event.fileBundleHashMilliseconds longLongValue]);
  e->set_file_bundle_binary_count([event.fileBundleBinaryCount longLongValue]);

  e->set_pid([event.pid unsignedIntValue]);
  e->set_ppid([event.ppid unsignedIntValue]);
  e->set_parent_name(NSStringToUTF8String(event.parentName));

  e->set_quarantine_data_url(NSStringToUTF8String(event.quarantineDataURL));
  e->set_quarantine_referer_url(NSStringToUTF8String(event.quarantineRefererURL));
  e->set_quarantine_timestamp([event.quarantineTimestamp timeIntervalSince1970]);
  e->set_quarantine_agent_bundle_id(NSStringToUTF8String(event.quarantineAgentBundleID));

  e->set_team_id(NSStringToUTF8String(event.teamID));
  e->set_signing_id(NSStringToUTF8String(event.signingID));
  e->set_cdhash(NSStringToUTF8String(event.cdhash));

  for (MOLCertificate *cert in event.signingChain) {
    auto c = e->add_signing_chain();
    c->set_sha256(NSStringToUTF8String(cert.SHA256));
    c->set_cn(NSStringToUTF8String(cert.commonName));
    c->set_org(NSStringToUTF8String(cert.orgName));
    c->set_ou(NSStringToUTF8String(cert.orgUnit));
    c->set_valid_from([cert.validFrom timeIntervalSince1970]);
    c->set_valid_until([cert.validUntil timeIntervalSince1970]);
  }

  return *e;
}

@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/santasyncservice/SNTSyncEventUpload.h"
16	#include <Foundation/Foundation.h>
17
18	#import <MOLCertificate/MOLCertificate.h>
19	#import <MOLXPCConnection/MOLXPCConnection.h>
20
21	#import "Source/common/SNTCommonEnums.h"
22	#import "Source/common/SNTConfigurator.h"
23	#import "Source/common/SNTFileInfo.h"
24	#import "Source/common/SNTLogging.h"
25	#import "Source/common/SNTStoredEvent.h"
26	#import "Source/common/SNTSyncConstants.h"
27	#import "Source/common/SNTXPCControlInterface.h"
28	#import "Source/common/String.h"
29	#import "Source/santasyncservice/NSData+Zlib.h"
30	#import "Source/santasyncservice/SNTSyncLogging.h"
31	#import "Source/santasyncservice/SNTSyncState.h"
32
33	#include <google/protobuf/arena.h>
34	#include "Source/santasyncservice/syncv1.pb.h"
35	namespace pbv1 = ::santa::sync::v1;
36
37	using santa::common::NSStringToUTF8String;
38
39	@implementation SNTSyncEventUpload
40
41	- (NSURL *)stageURL {	4✔
42	NSString *stageName = [@"eventupload" stringByAppendingFormat:@"/%@", self.syncState.machineID];	4✔
43	return [NSURL URLWithString:stageName relativeToURL:self.syncState.syncBaseURL];	4✔
44	}	4✔
45
46	- (BOOL)sync {	3✔
47	dispatch_semaphore_t sema = dispatch_semaphore_create(0);	3✔
48	[[self.daemonConn remoteObjectProxy] databaseEventsPending:^(NSArray *events) {	3✔
49	if (events.count) {	3!
50	[self uploadEvents:events];	3✔
51	}	3✔
52	dispatch_semaphore_signal(sema);	3✔
53	}];	3✔
54	return (dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER) == 0);	3✔
55	}	3✔
56
57	- (BOOL)uploadEvents:(NSArray *)events {	4✔
58	google::protobuf::Arena arena;	4✔
59	auto req = google::protobuf::Arena::Create<::pbv1::EventUploadRequest>(&arena);	4✔
60	auto uploadEvents = req->mutable_events();	4✔
61
62	NSMutableSet *eventIds = [NSMutableSet setWithCapacity:events.count];	4✔
63	for (SNTStoredEvent *event in events) {	5✔
64	uploadEvents->Add([self messageForEvent:event]);	5✔
65	if (event.idx) [eventIds addObject:event.idx];	5!
66	if (uploadEvents->size() >= self.syncState.eventBatchSize) break;	5✔
67	}	5✔
68
69	if (self.syncState.syncType == SNTSyncTypeNormal \|\|	4!
70	[[SNTConfigurator configurator] enableCleanSyncEventUpload]) {	4!
71	NSDictionary *r = [self performRequest:[self requestWithMessage:req]];	4✔
72	if (!r) return NO;	4!
73
74	// A list of bundle hashes that require their related binary events to be uploaded.
75	self.syncState.bundleBinaryRequests = r[kEventUploadBundleBinaries];	4✔
76
77	SLOGI(@"Uploaded %d events", uploadEvents->size());	4✔
78	}	4✔
79
80	// Remove event IDs. For Bundle Events the ID is 0 so nothing happens.
81	[[self.daemonConn remoteObjectProxy] databaseRemoveEventsWithIDs:[eventIds allObjects]];	4✔
82
83	// See if there are any events remaining to upload
84	if (uploadEvents->size() < events.count) {	4✔
85	NSRange nextEventsRange =	1✔
86	NSMakeRange(uploadEvents->size(), events.count - uploadEvents->size());	1✔
87	NSArray *nextEvents = [events subarrayWithRange:nextEventsRange];	1✔
88	return [self uploadEvents:nextEvents];	1✔
89	}	1✔
90
91	return YES;	3✔
92	}	4✔
93
94	- (::pbv1::Event)messageForEvent:(SNTStoredEvent *)event {	5✔
95	google::protobuf::Arena arena;	5✔
96	::pbv1::Event *e = google::protobuf::Arena::Create<::pbv1::Event>(&arena);	5✔
97
98	e->set_file_sha256(NSStringToUTF8String(event.fileSHA256));	5✔
99	e->set_file_path(NSStringToUTF8String([event.filePath stringByDeletingLastPathComponent]));	5✔
100	e->set_file_name(NSStringToUTF8String([event.filePath lastPathComponent]));	5✔
101	e->set_executing_user(NSStringToUTF8String(event.executingUser));	5✔
102	e->set_execution_time([event.occurrenceDate timeIntervalSince1970]);	5✔
103
104	for (NSString *user in event.loggedInUsers) {	5✔
105	e->add_logged_in_users(NSStringToUTF8String(user));	5✔
106	}	5✔
107	for (NSString *session in event.currentSessions) {	10✔
108	e->add_current_sessions(NSStringToUTF8String(session));	10✔
109	}	10✔
110
111	switch (event.decision) {	5✔
NEW 112	case SNTEventStateAllowUnknown: e->set_decision(::pbv1::ALLOW_UNKNOWN); break;	×
NEW 113	case SNTEventStateAllowBinary: e->set_decision(::pbv1::ALLOW_BINARY); break;	×
NEW 114	case SNTEventStateAllowCertificate:	×
NEW 115	e->set_decision(::pbv1::ALLOW_CERTIFICATE);	×
NEW 116	break;	×
NEW 117	break;	×
NEW 118	case SNTEventStateAllowScope: e->set_decision(::pbv1::ALLOW_SCOPE); break;	×
NEW 119	case SNTEventStateAllowTeamID: e->set_decision(::pbv1::ALLOW_TEAMID); break;	×
NEW 120	case SNTEventStateAllowSigningID: e->set_decision(::pbv1::ALLOW_SIGNINGID); break;	×
NEW 121	case SNTEventStateAllowCDHash: e->set_decision(::pbv1::ALLOW_CDHASH); break;	×
NEW 122	case SNTEventStateBlockUnknown: e->set_decision(::pbv1::BLOCK_UNKNOWN); break;	×
123	case SNTEventStateBlockBinary: e->set_decision(::pbv1::BLOCK_BINARY); break;	2✔
NEW 124	case SNTEventStateBlockCertificate: e->set_decision(::pbv1::BLOCK_CERTIFICATE); break;	×
NEW 125	case SNTEventStateBlockScope: e->set_decision(::pbv1::BLOCK_SCOPE); break;	×
NEW 126	case SNTEventStateBlockTeamID: e->set_decision(::pbv1::BLOCK_TEAMID); break;	×
NEW 127	case SNTEventStateBlockSigningID: e->set_decision(::pbv1::BLOCK_SIGNINGID); break;	×
NEW 128	case SNTEventStateBlockCDHash: e->set_decision(::pbv1::BLOCK_CDHASH); break;	×
129	case SNTEventStateBundleBinary:	3✔
130	e->set_decision(::pbv1::BUNDLE_BINARY);	3✔
131	e->clear_execution_time();	3✔
132	break;	3✔
NEW 133	default: e->set_decision(::pbv1::DECISION_UNKNOWN);	×
134	}	5✔
135
136	e->set_file_bundle_id(NSStringToUTF8String(event.fileBundleID));	5✔
137	e->set_file_bundle_path(NSStringToUTF8String(event.fileBundlePath));	5✔
138	e->set_file_bundle_executable_rel_path(NSStringToUTF8String(event.fileBundleExecutableRelPath));	5✔
139	e->set_file_bundle_name(NSStringToUTF8String(event.fileBundleName));	5✔
140	e->set_file_bundle_version(NSStringToUTF8String(event.fileBundleVersion));	5✔
141	e->set_file_bundle_version_string(NSStringToUTF8String(event.fileBundleVersionString));	5✔
142	e->set_file_bundle_hash(NSStringToUTF8String(event.fileBundleHash));	5✔
143	e->set_file_bundle_hash_millis([event.fileBundleHashMilliseconds longLongValue]);	5✔
144	e->set_file_bundle_binary_count([event.fileBundleBinaryCount longLongValue]);	5✔
145
146	e->set_pid([event.pid unsignedIntValue]);	5✔
147	e->set_ppid([event.ppid unsignedIntValue]);	5✔
148	e->set_parent_name(NSStringToUTF8String(event.parentName));	5✔
149
150	e->set_quarantine_data_url(NSStringToUTF8String(event.quarantineDataURL));	5✔
151	e->set_quarantine_referer_url(NSStringToUTF8String(event.quarantineRefererURL));	5✔
152	e->set_quarantine_timestamp([event.quarantineTimestamp timeIntervalSince1970]);	5✔
153	e->set_quarantine_agent_bundle_id(NSStringToUTF8String(event.quarantineAgentBundleID));	5✔
154
155	e->set_team_id(NSStringToUTF8String(event.teamID));	5✔
156	e->set_signing_id(NSStringToUTF8String(event.signingID));	5✔
157	e->set_cdhash(NSStringToUTF8String(event.cdhash));	5✔
158
159	for (MOLCertificate *cert in event.signingChain) {	9✔
160	auto c = e->add_signing_chain();	9✔
161	c->set_sha256(NSStringToUTF8String(cert.SHA256));	9✔
162	c->set_cn(NSStringToUTF8String(cert.commonName));	9✔
163	c->set_org(NSStringToUTF8String(cert.orgName));	9✔
164	c->set_ou(NSStringToUTF8String(cert.orgUnit));	9✔
165	c->set_valid_from([cert.validFrom timeIntervalSince1970]);	9✔
166	c->set_valid_until([cert.validUntil timeIntervalSince1970]);	9✔
167	}	9✔
168
169	return *e;	5✔
170	}	5✔
171
172	@end

google / santa / 9262563702

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