void makeEncryptKey(CFStringRef pass)
{
UInt32 passLen;
unsigned char *passData;
SecKeychainItemRef itemRef=NULL;
SecKeychainRef sysChain;
OSStatus secRes;
BF_KEY temp_key;
unsigned char encrypt_key[8];
if ((secRes = SecKeychainOpen(SYSTEM_KEYCHAIN, &sysChain)) != 0)
{
syslog(LOG_ERR,"Couldn't get system keychain: %d\n",secRes);
exit(-1);
}
if ((secRes = SecKeychainFindGenericPassword(sysChain, strlen(SECRET_SERVICENAME), SECRET_SERVICENAME, 0, NULL, &passLen, (void**)&passData, &itemRef))!=0)
{
syslog(LOG_ERR,"Error finding secret in keychain (%d). Failing",secRes);
exit(-1);
}
BF_set_key(&temp_key,passLen,passData);
BF_ecb_encrypt((const unsigned char*)CFStringGetCStringPtr(pass,CFStringGetFastestEncoding(pass)),encrypt_key,&temp_key,BF_ENCRYPT);
BF_set_key(&encrypt_bf_key,8,encrypt_key);
return;
}
bool fileExists(CFStringRef pathName)
{
struct stat fileStat;
if (stat(CFStringGetCStringPtr(pathName,CFStringGetFastestEncoding(pathName)),&fileStat))
return false;
return true;
}
void updateEncryption()
{
Boolean validKey;
CFStringRef password;
unsigned char md5[16];
char hash[32];
doEncrypt = (CFPreferencesGetAppBooleanValue(ENCRYPT_PREF_KEY,PREF_DOMAIN,&validKey))?kCFBooleanTrue:kCFBooleanFalse;
if (!validKey)
{
doEncrypt = kCFBooleanTrue;
CFPreferencesSetAppValue(ENCRYPT_PREF_KEY,doEncrypt,PREF_DOMAIN);
}
if (!(password = (CFStringRef)CFPreferencesCopyAppValue(PASSWORD_PREF_KEY,PREF_DOMAIN)))
{
password = CFSTR(DEFAULT_PASSWORD);
MD5((const unsigned char*)CFStringGetCStringPtr(password,CFStringGetFastestEncoding(password)),CFStringGetLength(password),md5);
for (int i=0; i<sizeof(md5); i++)
sprintf(hash+2*i,"%02x",md5[i]);
password = CFStringCreateWithCString(kCFAllocatorDefault,hash,kCFStringEncodingASCII);
CFPreferencesSetAppValue(PASSWORD_PREF_KEY,password,PREF_DOMAIN);
}
makeEncryptKey(password);
}
char* SDMCFStringGetString(CFStringRef str) {
char *cstr = NULL;
if (str) {
cstr = calloc(0x1, sizeof(char)*(CFStringGetLength(str)+0x1));
CFStringGetCString(str, cstr, CFStringGetLength(str)+0x1, CFStringGetFastestEncoding(str));
}
return cstr;
}
void
_bson_append_cftyperef (bson_string_t *retval, const char *label, CFTypeRef str)
{
if (str) {
if (CFGetTypeID (str) == CFStringGetTypeID ()) {
const char *cs = CFStringGetCStringPtr (str, CFStringGetFastestEncoding(str));
bson_string_append_printf (retval, "%s%s", label, cs);
}
}
}
void write_buffer(CFStringRef inData)
{
#ifdef DEBUG
syslog(LOG_ERR,"Writing buffer to file.");
#endif
if (CFWriteStreamGetStatus(logStream)!=kCFStreamStatusOpen)
{
CFWriteStreamSetProperty(logStream,kCFStreamPropertyAppendToFile,kCFBooleanTrue);
CFWriteStreamOpen(logStream);
}
if (!CFBooleanGetValue(doEncrypt))
{
CFWriteStreamWrite(logStream,(const UInt8*)CFStringGetCStringPtr(inData,CFStringGetFastestEncoding(inData)),CFStringGetLength(inData));
return;
}
int buff_pos = 0;
while (1)
{
int avail_space = 8-CFDataGetLength(encrypt_buffer); //space rem in buffer
int rem_to_copy = CFStringGetLength(inData)-buff_pos; //stuff in data that needs to be copied
int to_copy = rem_to_copy<avail_space?rem_to_copy:avail_space; //amount left to encryp, or avail space
if (avail_space)
{
UInt8 tmp_buff[8];
CFStringGetBytes(inData,CFRangeMake(buff_pos,to_copy),kCFStringEncodingNonLossyASCII,0,false,tmp_buff,8,NULL);
CFDataAppendBytes(encrypt_buffer,tmp_buff,to_copy);
avail_space -= to_copy;
if (avail_space>0) // small buffer? still space left?
break;
buff_pos += to_copy; //move along the buffer
}
UInt8 enc_buff[8];
BF_ecb_encrypt(CFDataGetBytePtr(encrypt_buffer),enc_buff,&encrypt_bf_key,BF_ENCRYPT);
CFWriteStreamWrite(logStream,enc_buff,8);
CFDataDeleteBytes(encrypt_buffer,CFRangeMake(0,8));
if (buff_pos==CFStringGetLength(inData)) //just in case buffer happens to fit perfectly
break;
}
return;
}
void *startSSDS(void *)
{
CFStringRef bundlePath = CopyMacBundlePath();
CFRelease(bundlePath);
char confPath[1024];
chdir(CFStringGetCStringPtr(bundlePath, CFStringGetFastestEncoding(bundlePath)));
sprintf(confPath, "%s/Test/ssds.cfg", CFStringGetCStringPtr(bundlePath, CFStringGetFastestEncoding(bundlePath)));
int argc = 3;
const char *argv[] = { "SSDS", "-C", "ssds.cfg" };
#else
int main(int argc, char *argv[])
{
#endif
try {
Initialise(argc, (char **)argv);
BuildRecogniser();
RunApplication();
}
catch (ATK_Error e){
int n = HRErrorCount();
printf("ATK Error %d\n",e.i);
for (int i=1; i<=n; i++)
printf(" %d. %s\n",i,HRErrorGetMess(i));
}
catch (HTK_Error e){
int n = HRErrorCount();
printf("HTK Error %d\n",e.i);
for (int i=1; i<=n; i++)
printf(" %d. %s\n",i,HRErrorGetMess(i));
}
#ifdef __APPLE__
CFRelease(confPath);
#endif
return 0;
}
void encode(ArgumentEncoder* encoder, CFStringRef string)
{
CFIndex length = CFStringGetLength(string);
CFStringEncoding encoding = CFStringGetFastestEncoding(string);
CFRange range = CFRangeMake(0, length);
CFIndex bufferLength = 0;
CFIndex numConvertedBytes = CFStringGetBytes(string, range, encoding, 0, false, 0, 0, &bufferLength);
ASSERT(numConvertedBytes == length);
Vector<UInt8, 128> buffer(bufferLength);
numConvertedBytes = CFStringGetBytes(string, range, encoding, 0, false, buffer.data(), buffer.size(), &bufferLength);
ASSERT(numConvertedBytes == length);
encoder->encodeEnum(encoding);
encoder->encodeVariableLengthByteArray(buffer);
}
bool outOfSpace(CFStringRef pathName)
{
Boolean validKey;
unsigned int minMeg;
struct statfs fileSys;
minMeg = CFPreferencesGetAppIntegerValue(MINMEG_PREF_KEY,PREF_DOMAIN,&validKey);
if (!validKey)
{
minMeg = DEFAULT_MEG;
CFPreferencesSetAppValue(MINMEG_PREF_KEY,CFNumberCreate(kCFAllocatorDefault,kCFNumberIntType,&minMeg),PREF_DOMAIN);
}
if (statfs(CFStringGetCStringPtr(pathName,CFStringGetFastestEncoding(pathName)),&fileSys))
return false;
if ((fileSys.f_bsize/1024)*(fileSys.f_bavail/1024) < minMeg)
return true;
return false;
}
bool
_mongoc_secure_transport_import_pem (const char *filename, const char *passphrase, CFArrayRef *items, SecExternalItemType *type)
{
SecExternalFormat format = kSecFormatPEMSequence;
SecItemImportExportKeyParameters params;
SecTransformRef sec_transform;
CFReadStreamRef read_stream;
CFDataRef dataref;
CFErrorRef error;
CFURLRef url;
OSStatus res;
if (!filename) {
MONGOC_INFO ("%s", "No certificate provided");
return false;
}
params.version = SEC_KEY_IMPORT_EXPORT_PARAMS_VERSION;
params.flags = 0;
params.passphrase = NULL;
params.alertTitle = NULL;
params.alertPrompt = NULL;
params.accessRef = NULL;
params.keyUsage = NULL;
params.keyAttributes = NULL;
if (passphrase) {
params.passphrase = CFStringCreateWithCString (kCFAllocatorDefault, passphrase, kCFStringEncodingUTF8);
}
url = CFURLCreateFromFileSystemRepresentation (kCFAllocatorDefault, (const UInt8 *)filename, strlen (filename), false);
read_stream = CFReadStreamCreateWithFile (kCFAllocatorDefault, url);
sec_transform = SecTransformCreateReadTransformWithReadStream (read_stream);
dataref = SecTransformExecute (sec_transform, &error);
if (error) {
CFStringRef str = CFErrorCopyDescription (error);
MONGOC_ERROR ("Failed importing PEM '%s': %s", filename, CFStringGetCStringPtr (str, CFStringGetFastestEncoding(str)));
CFRelease (str);
CFRelease (sec_transform);
CFRelease (read_stream);
CFRelease (url);
if (passphrase) {
CFRelease (params.passphrase);
}
return false;
}
res = SecItemImport (dataref, CFSTR(".pem"), &format, type, 0, ¶ms, NULL, items);
CFRelease (dataref);
CFRelease (sec_transform);
CFRelease (read_stream);
CFRelease (url);
if (passphrase) {
CFRelease (params.passphrase);
}
if (res) {
MONGOC_ERROR ("Failed importing PEM '%s' (code: %d)", filename, res);
return false;
}
return true;
}
