1  #include <sys/mman.h>
  2  #include <sys/types.h>
  3  #include <sys/stat.h>
  4  #include <unistd.h>
  5  #include <fcntl.h>
  6  #include <architecture/byte_order.h>
  7  #include <security_cdsa_utilities/cssmdb.h>
  8  #include "SharedMemoryClient.h"
  9  #include <string>
 10  #include <security_utilities/crc.h>
 11  #include <securityd_client/ssnotify.h>
 12  #include <Security/SecKeychain.h>
 13  
 14  using namespace Security;
 15  
 16  //=================================================================================
 17  //                          SharedMemoryClient
 18  //=================================================================================
 19  
 20  #if !defined(NDEBUG)
 21  static std::string unixerrorstr(int errnum) {
 22      string errstr;
 23      char buf[1024];
 24      // might return ERANGE
 25      /* int rx = */ strerror_r(errnum, buf, sizeof(buf));
 26      errstr = string(buf);
 27      errstr += "(" + to_string(errnum) + ")";
 28      return errstr;
 29  }
 30  #endif
 31  
 32  SharedMemoryClient::SharedMemoryClient (const char* segmentName, SegmentOffsetType segmentSize, uid_t uid)
 33  {
 34  	StLock<Mutex> _(mMutex);
 35  	
 36  	mSegmentName = segmentName;
 37  	mSegmentSize = segmentSize;
 38      mSegment = (u_int8_t*) MAP_FAILED;
 39      mDataArea = mDataPtr = 0;
 40      mUID = uid;
 41      
 42      secdebug("MDSPRIVACY","[%03d] creating SharedMemoryClient with segmentName %s, size: %d", mUID, segmentName, segmentSize);
 43  
 44      if (segmentSize < sizeof(u_int32_t))
 45  		return;
 46  
 47  	// make the name
 48  	int segmentDescriptor;
 49  	{
 50          std::string name(SharedMemoryCommon::SharedMemoryFilePath(mSegmentName.c_str(), mUID));
 51  
 52  		// make a connection to the shared memory block
 53  		segmentDescriptor = open (name.c_str(), O_RDONLY, S_IROTH);
 54  		if (segmentDescriptor < 0) // error on opening the shared memory segment?
 55  		{
 56              secdebug("MDSPRIVACY","[%03d] SharedMemoryClient open of %s failed: %s", mUID, name.c_str(), unixerrorstr(errno).c_str());
 57  			// CssmError::throwMe (CSSM_ERRCODE_INTERNAL_ERROR);
 58  			return;
 59  		}
 60  	}
 61  
 62      // check that the file size is large enough to support operations
 63      struct stat statResult = {};
 64      int result = fstat(segmentDescriptor, &statResult);
 65      if(result) {
 66          secdebug("MDSPRIVACY","[%03d] SharedMemoryClient fstat failed: %d/%s", mUID, result, unixerrorstr(errno).c_str());
 67          UnixError::throwMe(errno);
 68      }
 69  
 70      off_t sz = statResult.st_size;
 71      if(sz < sizeof(SegmentOffsetType)) {
 72          close(segmentDescriptor);
 73          return;
 74      }
 75  
 76      if(sz > 4*segmentSize) {
 77          // File is too ridiculously large. Quit.
 78          close(segmentDescriptor);
 79          return;
 80      }
 81  
 82  	// map the segment into place
 83  	mSegment = (u_int8_t*) mmap (NULL, segmentSize, PROT_READ, MAP_SHARED, segmentDescriptor, 0);
 84  	close (segmentDescriptor);
 85  
 86  	if (mSegment == MAP_FAILED)
 87  	{
 88          secdebug("MDSPRIVACY","[%03d] SharedMemoryClient mmap failed: %d", mUID, errno);
 89  		return;
 90  	}
 91  	
 92  	mDataArea = mSegment + sizeof (SegmentOffsetType);
 93  	mDataMax = mSegment + sz;
 94  	mDataPtr = mDataArea + GetProducerCount ();
 95  }
 96  
 97  
 98  
 99  SharedMemoryClient::~SharedMemoryClient ()
100  {
101      if (!uninitialized()) {
102          StLock<Mutex> _(mMutex);
103          munmap (mSegment, mSegmentSize);
104      }
105  }
106  
107  
108  SegmentOffsetType SharedMemoryClient::GetProducerCount ()
109  {
110      if (uninitialized()) {
111          secdebug("MDSPRIVACY","[%03d] SharedMemoryClient::GetProducerCount uninitialized", mUID);
112  		CssmError::throwMe(CSSM_ERRCODE_INTERNAL_ERROR);
113  	}
114      if( ((u_int8_t*) (((u_int32_t*) mSegment) + 1)) > mDataMax) {
115          // Check we can actually read this u_int32_t
116          secdebug("MDSPRIVACY","[%03d] SharedMemoryClient::GetProducerCount uint > mDataMax", mUID);
117          CssmError::throwMe(CSSM_ERRCODE_INTERNAL_ERROR);
118      }
119  
120  	SegmentOffsetType offset = OSSwapBigToHostInt32 (*(u_int32_t*) mSegment);
121      if (&mSegment[offset] >= mDataMax) {
122          secdebug("MDSPRIVACY","[%03d] SharedMemoryClient::GetProducerCount offset > mDataMax", mUID);
123  		CssmError::throwMe(CSSM_ERRCODE_INTERNAL_ERROR);
124      }
125  
126      return offset;
127  }
128  
129  void SharedMemoryClient::ReadData (void* buffer, SegmentOffsetType length)
130  {
131      if (uninitialized()) {
132          secdebug("MDSPRIVACY","[%03d] ReadData mSegment fail uninitialized: %p", mUID, mSegment);
133          CssmError::throwMe(CSSM_ERRCODE_INTERNAL_ERROR);
134      }
135      
136  	u_int8_t* bptr = (u_int8_t*) buffer;
137  
138  	SegmentOffsetType bytesToEnd = (SegmentOffsetType)(mDataMax - mDataPtr);
139  	
140  	// figure out how many bytes we can read
141  	SegmentOffsetType bytesToRead = (length <= bytesToEnd) ? length : bytesToEnd;
142  
143  	// move the first part of the data
144  	memcpy (bptr, mDataPtr, bytesToRead);
145  	bptr += bytesToRead;
146  	
147  	// see if we have anything else to read
148  	mDataPtr += bytesToRead;
149  	
150  	length -= bytesToRead;
151  	if (length != 0)
152  	{
153  		mDataPtr = mDataArea;
154  		memcpy(bptr, mDataPtr, length);
155  		mDataPtr += length;
156  	}
157  }
158  
159  
160  
161  SegmentOffsetType SharedMemoryClient::ReadOffset()
162  {
163  	SegmentOffsetType offset;
164  	ReadData(&offset, sizeof(SegmentOffsetType));
165  	offset = OSSwapBigToHostInt32 (offset);
166  	return offset;
167  }
168  
169  
170  
171  bool SharedMemoryClient::ReadMessage (void* message, SegmentOffsetType &length, UnavailableReason &ur)
172  {
173  	StLock<Mutex> _(mMutex);
174  
175      if (uninitialized()) {
176  		secdebug("MDSPRIVACY","[%03d] ReadMessage mSegment fail uninitialized: %p", mUID, mSegment);
177  		CssmError::throwMe(CSSM_ERRCODE_INTERNAL_ERROR);
178  	}
179  
180  	ur = kURNone;
181  	
182  	size_t offset = mDataPtr - mDataArea;
183  	if (offset == GetProducerCount())
184  	{
185          secdebug("MDSPRIVACY","[%03d] ReadMessage GetProducerCount()", mUID);
186  		ur = kURNoMessage;
187  		return false;
188  	}
189  	
190  	// get the length of the message in the buffer
191  	length = ReadOffset();
192  	
193  	// we have the possibility that data is correct, figure out where the data is actually located
194  	// get the length of the message stored there
195  	if (length == 0 || length >= kPoolAvailableForData)
196  	{
197          secdebug("MDSPRIVACY","[%03d] ReadMessage length error: %d", mUID, length);
198          ur = (length == 0) ? kURNoMessage : kURBufferCorrupt;
199  
200  		// something's gone wrong, reset.
201  		mDataPtr = mDataArea + GetProducerCount ();
202  		return false;
203  	}
204  	
205  	// read the crc
206  	SegmentOffsetType crc = ReadOffset();
207  
208  	// read the data into the buffer
209  	ReadData (message, length);
210  	
211  	// calculate the CRC
212  	SegmentOffsetType crc2 = CalculateCRC((u_int8_t*) message, length);
213  	if (crc != crc2)
214  	{
215  		ur = kURBufferCorrupt;
216  		mDataPtr = mDataArea + GetProducerCount ();
217  		return false;
218  	}
219  
220  	return true;
221  }
222  
223  //=================================================================================
224  //                          SharedMemoryCommon
225  //=================================================================================
226  
227  std::string SharedMemoryCommon::SharedMemoryFilePath(const char *segmentName, uid_t uid) {
228      std::string path;
229      uid = SharedMemoryCommon::fixUID(uid);
230      path = SharedMemoryCommon::kMDSMessagesDirectory;   // i.e. /private/var/db/mds/messages/
231      if (uid != 0) {
232          path += std::to_string(uid) + "/";              // e.g. /private/var/db/mds/messages/501/
233      }
234  
235      path += SharedMemoryCommon::kUserPrefix;            // e.g. /var/db/mds/messages/se_
236      path += segmentName;                                // e.g. /var/db/mds/messages/501/se_SecurityMessages
237      return path;
238  }
239  
240  std::string SharedMemoryCommon::notificationDescription(int domain, int event) {
241      string domainstr, eventstr;
242  
243      switch (domain) {
244          case Security::SecurityServer::kNotificationDomainAll:        domainstr = "all";      break;
245          case Security::SecurityServer::kNotificationDomainDatabase:   domainstr = "database"; break;
246          case Security::SecurityServer::kNotificationDomainPCSC:       domainstr = "pcsc";     break;
247          case Security::SecurityServer::kNotificationDomainCDSA:       domainstr = "CDSA";     break;
248          default:
249              domainstr = "unknown";
250              break;
251      }
252  
253      switch (event) {
254          case kSecLockEvent:                 eventstr = "lock";              break;
255          case kSecUnlockEvent:               eventstr = "unlock";            break;
256          case kSecAddEvent:                  eventstr = "add";               break;
257          case kSecDeleteEvent:               eventstr = "delete";            break;
258          case kSecUpdateEvent:               eventstr = "update";            break;
259          case kSecPasswordChangedEvent:      eventstr = "passwordChange";    break;
260          case kSecDefaultChangedEvent:       eventstr = "defaultChange";     break;
261          case kSecDataAccessEvent:           eventstr = "dataAccess";        break;
262          case kSecKeychainListChangedEvent:  eventstr = "listChange";        break;
263          case kSecTrustSettingsChangedEvent: eventstr = "trustSettings";     break;
264          default:
265              domainstr = "unknown";
266              break;
267      }
268  
269      return "Domain: " + domainstr + ", Event: " + eventstr;
270  }