void fs_cmd_ls(int argc, char** argv) { Volume* volume; io_func* io; if(argc < 2) { bufferPrintf("usage: %s <partition> <directory>\r\n", argv[0]); return; } io = bdev_open(parseNumber(argv[1])); if(io == NULL) { bufferPrintf("fs: cannot read partition!\r\n"); return; } volume = openVolume(io); if(volume == NULL) { bufferPrintf("fs: cannot openHFS volume!\r\n"); return; } if(argc > 2) hfs_ls(volume, argv[2]); else hfs_ls(volume, "/"); closeVolume(volume); CLOSE(io); }
HfsContext* hfslib_open(char* fileName) { BOOL success = FALSE; HfsContext* ctx = (HfsContext*)malloc(sizeof(HfsContext)); if (ctx == NULL) { return NULL; } memset (ctx, 0, sizeof(*ctx)); do { ctx->io = openFlatFile(fileName); if(ctx->io == NULL) { //fprintf(stderr, "error: Cannot open image-file.\n"); break; } ctx->volume = openVolume(ctx->io); if(ctx->volume == NULL) { //fprintf(stderr, "error: Cannot open volume.\n"); break; } success = true; } while (FALSE); if (!success) { hfslib_close(ctx); ctx = NULL; } return ctx; }
bool Win32RedBookDevice::open() { if(mAcquired) { setLastError("Device is already open."); return(false); } U32 error; // open the device MCI_OPEN_PARMS openParms; #ifdef UNICODE openParms.lpstrDeviceType = (LPCWSTR)MCI_DEVTYPE_CD_AUDIO; UTF16 buf[512]; convertUTF8toUTF16((UTF8 *)mDeviceName, buf, sizeof(buf)); openParms.lpstrElementName = buf; #else openParms.lpstrDeviceType = (LPCSTR)MCI_DEVTYPE_CD_AUDIO; openParms.lpstrElementName = mDeviceName; #endif error = mciSendCommand(0, MCI_OPEN, MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID, (DWORD_PTR)(LPMCI_OPEN_PARMS)&openParms); if(error) { // attempt to open as a shared device error = mciSendCommand(NULL, MCI_OPEN, MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID|MCI_OPEN_SHAREABLE, (DWORD_PTR)(LPMCI_OPEN_PARMS)&openParms); if(error) { setLastError(error); return(false); } } // set time mode to milliseconds MCI_SET_PARMS setParms; setParms.dwTimeFormat = MCI_FORMAT_MILLISECONDS; error = mciSendCommand(openParms.wDeviceID, MCI_SET, MCI_SET_TIME_FORMAT, (DWORD_PTR)(LPMCI_SET_PARMS)&setParms); if(error) { setLastError(error); return(false); } // mDeviceId = openParms.wDeviceID; mAcquired = true; openVolume(); setLastError(""); return(true); }
void fs_cmd_extract(int argc, char** argv) { Volume* volume; io_func* io; if(argc < 4) { bufferPrintf("usage: %s <partition> <file> <location>\r\n", argv[0]); return; } io = bdev_open(parseNumber(argv[1])); if(io == NULL) { bufferPrintf("fs: cannot read partition!\r\n"); return; } volume = openVolume(io); if(volume == NULL) { bufferPrintf("fs: cannot openHFS volume!\r\n"); return; } HFSPlusCatalogRecord* record; record = getRecordFromPath(argv[2], volume, NULL, NULL); if(record != NULL) { if(record->recordType == kHFSPlusFileRecord) { uint8_t* buffer; uint32_t size = readHFSFile((HFSPlusCatalogFile*)record, &buffer, volume); uint32_t address = parseNumber(argv[3]); memcpy((uint8_t*)address, buffer, size); free(buffer); bufferPrintf("%d bytes of %s extracted to 0x%x\r\n", size, argv[2], address); } else { bufferPrintf("Not a file, record type: %x\r\n", record->recordType); } } else { bufferPrintf("No such file or directory\r\n"); } free(record); closeVolume(volume); CLOSE(io); }
void fs_cmd_cat(int argc, char** argv) { Volume* volume; io_func* io; if(argc < 3) { bufferPrintf("usage: %s <partition> <file>\r\n", argv[0]); return; } io = bdev_open(parseNumber(argv[1])); if(io == NULL) { bufferPrintf("fs: cannot read partition!\r\n"); return; } volume = openVolume(io); if(volume == NULL) { bufferPrintf("fs: cannot openHFS volume!\r\n"); return; } HFSPlusCatalogRecord* record; record = getRecordFromPath(argv[2], volume, NULL, NULL); if(record != NULL) { if(record->recordType == kHFSPlusFileRecord) { uint8_t* buffer; uint32_t size = readHFSFile((HFSPlusCatalogFile*)record, &buffer, volume); buffer = realloc(buffer, size + 1); buffer[size] = '\0'; bufferPrintf("%s\r\n", buffer); free(buffer); } else { bufferPrintf("Not a file, record type: %x\r\n", record->recordType); } } else { bufferPrintf("No such file or directory\r\n"); } free(record); closeVolume(volume); CLOSE(io); }
//------------------------------------------------------------------------------ bool UnixRedBookDevice::open() { #if !defined(__FreeBSD__) if(mAcquired) { setLastError("Device is already open."); return(false); } // open the device mCD = SDL_CDOpen(mDeviceId); if (mCD == NULL) { setLastError(SDL_GetError()); return false; } mAcquired = true; openVolume(); setLastError(""); return(true); #endif // !defined(__FreeBSD__) }
int main(int argc, const char *argv[]) { io_func* io; Volume* volume; TestByteOrder(); if(argc < 3) { printf("usage: %s <image-file> <ls|cat|mv|symlink|mkdir|add|rm|chmod|extract|extractall|rmall|addall|grow|getattr|debug> <arguments>\n", argv[0]); return 0; } io = openFlatFile(argv[1]); if(io == NULL) { fprintf(stderr, "error: Cannot open image-file.\n"); return 1; } volume = openVolume(io); if(volume == NULL) { fprintf(stderr, "error: Cannot open volume.\n"); CLOSE(io); return 1; } if(argc > 1) { if(strcmp(argv[2], "ls") == 0) { cmd_ls(volume, argc - 2, argv + 2); } else if(strcmp(argv[2], "cat") == 0) { cmd_cat(volume, argc - 2, argv + 2); } else if(strcmp(argv[2], "mv") == 0) { cmd_mv(volume, argc - 2, argv + 2); } else if(strcmp(argv[2], "symlink") == 0) { cmd_symlink(volume, argc - 2, argv + 2); } else if(strcmp(argv[2], "mkdir") == 0) { cmd_mkdir(volume, argc - 2, argv + 2); } else if(strcmp(argv[2], "add") == 0) { cmd_add(volume, argc - 2, argv + 2); } else if(strcmp(argv[2], "rm") == 0) { cmd_rm(volume, argc - 2, argv + 2); } else if(strcmp(argv[2], "chmod") == 0) { cmd_chmod(volume, argc - 2, argv + 2); } else if(strcmp(argv[2], "extract") == 0) { cmd_extract(volume, argc - 2, argv + 2); } else if(strcmp(argv[2], "extractall") == 0) { cmd_extractall(volume, argc - 2, argv + 2); } else if(strcmp(argv[2], "rmall") == 0) { cmd_rmall(volume, argc - 2, argv + 2); } else if(strcmp(argv[2], "addall") == 0) { cmd_addall(volume, argc - 2, argv + 2); } else if(strcmp(argv[2], "grow") == 0) { cmd_grow(volume, argc - 2, argv + 2); } else if(strcmp(argv[2], "getattr") == 0) { cmd_getattr(volume, argc - 2, argv + 2); } else if(strcmp(argv[2], "debug") == 0) { if(argc > 3 && strcmp(argv[3], "verbose") == 0) { debugBTree(volume->catalogTree, TRUE); } else { debugBTree(volume->catalogTree, FALSE); } } } closeVolume(volume); CLOSE(io); return 0; }
int main(int argc, char* argv[]) { init_libxpwn(); Dictionary* info; Dictionary* firmwarePatches; Dictionary* patchDict; ArrayValue* patchArray; void* buffer; StringValue* actionValue; StringValue* pathValue; StringValue* fileValue; StringValue* patchValue; char* patchPath; char* rootFSPathInIPSW; io_func* rootFS; Volume* rootVolume; size_t rootSize; size_t preferredRootSize = 0; size_t minimumRootSize = 0; char* ramdiskFSPathInIPSW; unsigned int ramdiskKey[16]; unsigned int ramdiskIV[16]; unsigned int* pRamdiskKey = NULL; unsigned int* pRamdiskIV = NULL; io_func* ramdiskFS; Volume* ramdiskVolume; char* updateRamdiskFSPathInIPSW = NULL; int i; OutputState* outputState; char* bundlePath; char* bundleRoot = "FirmwareBundles/"; int mergePaths; char* outputIPSW; void* imageBuffer; size_t imageSize; AbstractFile* bootloader39 = NULL; AbstractFile* bootloader46 = NULL; AbstractFile* applelogo = NULL; AbstractFile* recoverymode = NULL; char noWipe = FALSE; char unlockBaseband = FALSE; char selfDestruct = FALSE; char use39 = FALSE; char use46 = FALSE; char doBootNeuter = FALSE; char updateBB = FALSE; char useMemory = FALSE; unsigned int key[16]; unsigned int iv[16]; unsigned int* pKey = NULL; unsigned int* pIV = NULL; if(argc < 3) { XLOG(0, "usage %s <input.ipsw> <target.ipsw> [-b <bootimage.png>] [-r <recoveryimage.png>] [-s <system partition size>] [-memory] [-bbupdate] [-nowipe] [-e \"<action to exclude>\"] [[-unlock] [-use39] [-use46] [-cleanup] -3 <bootloader 3.9 file> -4 <bootloader 4.6 file>] <package1.tar> <package2.tar>...\n", argv[0]); return 0; } outputIPSW = argv[2]; int* toRemove = NULL; int numToRemove = 0; for(i = 3; i < argc; i++) { if(argv[i][0] != '-') { break; } if(strcmp(argv[i], "-memory") == 0) { useMemory = TRUE; continue; } if(strcmp(argv[i], "-s") == 0) { int size; sscanf(argv[i + 1], "%d", &size); preferredRootSize = size; i++; continue; } if(strcmp(argv[i], "-nowipe") == 0) { noWipe = TRUE; continue; } if(strcmp(argv[i], "-bbupdate") == 0) { updateBB = TRUE; continue; } if(strcmp(argv[i], "-e") == 0) { numToRemove++; toRemove = realloc(toRemove, numToRemove * sizeof(int)); toRemove[numToRemove - 1] = i + 1; i++; continue; } if(strcmp(argv[i], "-unlock") == 0) { unlockBaseband = TRUE; continue; } if(strcmp(argv[i], "-cleanup") == 0) { selfDestruct = TRUE; continue; } if(strcmp(argv[i], "-use39") == 0) { if(use46) { XLOG(0, "error: select only one of -use39 and -use46\n"); exit(1); } use39 = TRUE; continue; } if(strcmp(argv[i], "-use46") == 0) { if(use39) { XLOG(0, "error: select only one of -use39 and -use46\n"); exit(1); } use46 = TRUE; continue; } if(strcmp(argv[i], "-b") == 0) { applelogo = createAbstractFileFromFile(fopen(argv[i + 1], "rb")); if(!applelogo) { XLOG(0, "cannot open %s\n", argv[i + 1]); exit(1); } i++; continue; } if(strcmp(argv[i], "-r") == 0) { recoverymode = createAbstractFileFromFile(fopen(argv[i + 1], "rb")); if(!recoverymode) { XLOG(0, "cannot open %s\n", argv[i + 1]); exit(1); } i++; continue; } if(strcmp(argv[i], "-3") == 0) { bootloader39 = createAbstractFileFromFile(fopen(argv[i + 1], "rb")); if(!bootloader39) { XLOG(0, "cannot open %s\n", argv[i + 1]); exit(1); } i++; continue; } if(strcmp(argv[i], "-4") == 0) { bootloader46 = createAbstractFileFromFile(fopen(argv[i + 1], "rb")); if(!bootloader46) { XLOG(0, "cannot open %s\n", argv[i + 1]); exit(1); } i++; continue; } } mergePaths = i; if(use39 || use46 || unlockBaseband || selfDestruct || bootloader39 || bootloader46) { if(!(bootloader39) || !(bootloader46)) { XLOG(0, "error: you must specify both bootloader files.\n"); exit(1); } else { doBootNeuter = TRUE; } } info = parseIPSW2(argv[1], bundleRoot, &bundlePath, &outputState, useMemory); if(info == NULL) { XLOG(0, "error: Could not load IPSW\n"); exit(1); } firmwarePatches = (Dictionary*)getValueByKey(info, "FilesystemPatches"); int j; for(j = 0; j < numToRemove; j++) { removeKey(firmwarePatches, argv[toRemove[j]]); } free(toRemove); firmwarePatches = (Dictionary*)getValueByKey(info, "FirmwarePatches"); patchDict = (Dictionary*) firmwarePatches->values; while(patchDict != NULL) { fileValue = (StringValue*) getValueByKey(patchDict, "File"); StringValue* keyValue = (StringValue*) getValueByKey(patchDict, "Key"); StringValue* ivValue = (StringValue*) getValueByKey(patchDict, "IV"); pKey = NULL; pIV = NULL; if(keyValue) { sscanf(keyValue->value, "%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x", &key[0], &key[1], &key[2], &key[3], &key[4], &key[5], &key[6], &key[7], &key[8], &key[9], &key[10], &key[11], &key[12], &key[13], &key[14], &key[15]); pKey = key; } if(ivValue) { sscanf(ivValue->value, "%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x", &iv[0], &iv[1], &iv[2], &iv[3], &iv[4], &iv[5], &iv[6], &iv[7], &iv[8], &iv[9], &iv[10], &iv[11], &iv[12], &iv[13], &iv[14], &iv[15]); pIV = iv; } if(strcmp(patchDict->dValue.key, "Restore Ramdisk") == 0) { ramdiskFSPathInIPSW = fileValue->value; if(pKey) { memcpy(ramdiskKey, key, sizeof(key)); memcpy(ramdiskIV, iv, sizeof(iv)); pRamdiskKey = ramdiskKey; pRamdiskIV = ramdiskIV; } else { pRamdiskKey = NULL; pRamdiskIV = NULL; } } if(strcmp(patchDict->dValue.key, "Update Ramdisk") == 0) { updateRamdiskFSPathInIPSW = fileValue->value; } patchValue = (StringValue*) getValueByKey(patchDict, "Patch2"); if(patchValue) { if(noWipe) { XLOG(0, "%s: ", patchDict->dValue.key); fflush(stdout); doPatch(patchValue, fileValue, bundlePath, &outputState, pKey, pIV, useMemory); patchDict = (Dictionary*) patchDict->dValue.next; continue; /* skip over the normal Patch */ } } patchValue = (StringValue*) getValueByKey(patchDict, "Patch"); if(patchValue) { XLOG(0, "%s: ", patchDict->dValue.key); fflush(stdout); doPatch(patchValue, fileValue, bundlePath, &outputState, pKey, pIV, useMemory); } if(strcmp(patchDict->dValue.key, "AppleLogo") == 0 && applelogo) { XLOG(0, "replacing %s\n", fileValue->value); fflush(stdout); ASSERT((imageBuffer = replaceBootImage(getFileFromOutputState(&outputState, fileValue->value), pKey, pIV, applelogo, &imageSize)) != NULL, "failed to use new image"); addToOutput(&outputState, fileValue->value, imageBuffer, imageSize); } if(strcmp(patchDict->dValue.key, "RecoveryMode") == 0 && recoverymode) { XLOG(0, "replacing %s\n", fileValue->value); fflush(stdout); ASSERT((imageBuffer = replaceBootImage(getFileFromOutputState(&outputState, fileValue->value), pKey, pIV, recoverymode, &imageSize)) != NULL, "failed to use new image"); addToOutput(&outputState, fileValue->value, imageBuffer, imageSize); } patchDict = (Dictionary*) patchDict->dValue.next; } fileValue = (StringValue*) getValueByKey(info, "RootFilesystem"); rootFSPathInIPSW = fileValue->value; size_t defaultRootSize = ((IntegerValue*) getValueByKey(info, "RootFilesystemSize"))->value; minimumRootSize = defaultRootSize * 1000 * 1000; minimumRootSize -= minimumRootSize % 512; if(preferredRootSize == 0) { preferredRootSize = defaultRootSize; } rootSize = preferredRootSize * 1000 * 1000; rootSize -= rootSize % 512; if(useMemory) { buffer = malloc(rootSize); } else { buffer = NULL; } if(buffer == NULL) { XLOG(2, "using filesystem backed temporary storage\n"); } extractDmg( createAbstractFileFromFileVault(getFileFromOutputState(&outputState, rootFSPathInIPSW), ((StringValue*)getValueByKey(info, "RootFilesystemKey"))->value), openRoot((void**)&buffer, &rootSize), -1); rootFS = IOFuncFromAbstractFile(openRoot((void**)&buffer, &rootSize)); rootVolume = openVolume(rootFS); XLOG(0, "Growing root to minimum: %ld\n", (long) defaultRootSize); fflush(stdout); grow_hfs(rootVolume, minimumRootSize); if(rootSize > minimumRootSize) { XLOG(0, "Growing root: %ld\n", (long) preferredRootSize); fflush(stdout); grow_hfs(rootVolume, rootSize); } firmwarePatches = (Dictionary*)getValueByKey(info, "FilesystemPatches"); patchArray = (ArrayValue*) firmwarePatches->values; while(patchArray != NULL) { for(i = 0; i < patchArray->size; i++) { patchDict = (Dictionary*) patchArray->values[i]; fileValue = (StringValue*) getValueByKey(patchDict, "File"); actionValue = (StringValue*) getValueByKey(patchDict, "Action"); if(strcmp(actionValue->value, "ReplaceKernel") == 0) { pathValue = (StringValue*) getValueByKey(patchDict, "Path"); XLOG(0, "replacing kernel... %s -> %s\n", fileValue->value, pathValue->value); fflush(stdout); add_hfs(rootVolume, getFileFromOutputState(&outputState, fileValue->value), pathValue->value); } if(strcmp(actionValue->value, "Patch") == 0) { patchValue = (StringValue*) getValueByKey(patchDict, "Patch"); patchPath = (char*) malloc(sizeof(char) * (strlen(bundlePath) + strlen(patchValue->value) + 2)); strcpy(patchPath, bundlePath); strcat(patchPath, "/"); strcat(patchPath, patchValue->value); XLOG(0, "patching %s (%s)... ", fileValue->value, patchPath); doPatchInPlace(rootVolume, fileValue->value, patchPath); free(patchPath); } } patchArray = (ArrayValue*) patchArray->dValue.next; } for(; mergePaths < argc; mergePaths++) { XLOG(0, "merging %s\n", argv[mergePaths]); AbstractFile* tarFile = createAbstractFileFromFile(fopen(argv[mergePaths], "rb")); if(tarFile == NULL) { XLOG(1, "cannot find %s, make sure your slashes are in the right direction\n", argv[mergePaths]); releaseOutput(&outputState); closeRoot(buffer); exit(0); } hfs_untar(rootVolume, tarFile); tarFile->close(tarFile); } if(pRamdiskKey) { ramdiskFS = IOFuncFromAbstractFile(openAbstractFile2(getFileFromOutputStateForOverwrite(&outputState, ramdiskFSPathInIPSW), pRamdiskKey, pRamdiskIV)); } else { XLOG(0, "unencrypted ramdisk\n"); ramdiskFS = IOFuncFromAbstractFile(openAbstractFile(getFileFromOutputStateForOverwrite(&outputState, ramdiskFSPathInIPSW))); } ramdiskVolume = openVolume(ramdiskFS); XLOG(0, "growing ramdisk: %d -> %d\n", ramdiskVolume->volumeHeader->totalBlocks * ramdiskVolume->volumeHeader->blockSize, (ramdiskVolume->volumeHeader->totalBlocks + 4) * ramdiskVolume->volumeHeader->blockSize); grow_hfs(ramdiskVolume, (ramdiskVolume->volumeHeader->totalBlocks + 4) * ramdiskVolume->volumeHeader->blockSize); if(doBootNeuter) { firmwarePatches = (Dictionary*)getValueByKey(info, "BasebandPatches"); if(firmwarePatches != NULL) { patchDict = (Dictionary*) firmwarePatches->values; while(patchDict != NULL) { pathValue = (StringValue*) getValueByKey(patchDict, "Path"); fileValue = (StringValue*) getValueByKey(patchDict, "File"); if(fileValue) { XLOG(0, "copying %s -> %s... ", fileValue->value, pathValue->value); fflush(stdout); if(copyAcrossVolumes(ramdiskVolume, rootVolume, fileValue->value, pathValue->value)) { patchValue = (StringValue*) getValueByKey(patchDict, "Patch"); if(patchValue) { patchPath = malloc(sizeof(char) * (strlen(bundlePath) + strlen(patchValue->value) + 2)); strcpy(patchPath, bundlePath); strcat(patchPath, "/"); strcat(patchPath, patchValue->value); XLOG(0, "patching %s (%s)... ", pathValue->value, patchPath); fflush(stdout); doPatchInPlace(rootVolume, pathValue->value, patchPath); free(patchPath); } } } if(strcmp(patchDict->dValue.key, "Bootloader 3.9") == 0 && bootloader39 != NULL) { add_hfs(rootVolume, bootloader39, pathValue->value); } if(strcmp(patchDict->dValue.key, "Bootloader 4.6") == 0 && bootloader46 != NULL) { add_hfs(rootVolume, bootloader46, pathValue->value); } patchDict = (Dictionary*) patchDict->dValue.next; } } fixupBootNeuterArgs(rootVolume, unlockBaseband, selfDestruct, use39, use46); } createRestoreOptions(ramdiskVolume, preferredRootSize, updateBB); closeVolume(ramdiskVolume); CLOSE(ramdiskFS); if(updateRamdiskFSPathInIPSW) removeFileFromOutputState(&outputState, updateRamdiskFSPathInIPSW); closeVolume(rootVolume); CLOSE(rootFS); buildDmg(openRoot((void**)&buffer, &rootSize), getFileFromOutputStateForReplace(&outputState, rootFSPathInIPSW)); closeRoot(buffer); writeOutput(&outputState, outputIPSW); releaseDictionary(info); free(bundlePath); return 0; }
void images_install(void* newData, size_t newDataLen, uint32_t newFourcc, uint32_t replaceFourcc) { ImageDataList* list = NULL; ImageDataList* cur = NULL; ImageDataList* toReplace = NULL; ImageDataList* verify = NULL; int isReplace = (replaceFourcc != newFourcc) ? TRUE : FALSE; int isUpgrade = FALSE; Image* curImage = imageList; while(curImage != NULL) { if(cur == NULL) { list = cur = verify = malloc(sizeof(ImageDataList)); } else { cur->next = malloc(sizeof(ImageDataList)); cur = cur->next; } bufferPrintf("Reading: "); print_fourcc(curImage->type); bufferPrintf(" (%d bytes)\r\n", curImage->padded); cur->type = curImage->type; cur->next = NULL; cur->data = malloc(curImage->padded); nor_read(cur->data, curImage->offset, curImage->padded); if(isReplace && cur->type == replaceFourcc) { isUpgrade = TRUE; } else if(cur->type == newFourcc) { toReplace = cur; } curImage = curImage->next; } if(!isUpgrade) { bufferPrintf("Performing installation... (%d bytes)\r\n", newDataLen); ImageDataList* ibox = malloc(sizeof(ImageDataList)); ibox->type = replaceFourcc; ibox->data = toReplace->data; ibox->next = toReplace->next; toReplace->next = ibox; toReplace->data = images_inject_img3(toReplace->data, newData, newDataLen); images_change_type(ibox->data, ibox->type); } else { bufferPrintf("Performing upgrade... (%d bytes)\r\n", newDataLen); void* newIBoot = images_inject_img3(toReplace->data, newData, newDataLen); free(toReplace->data); toReplace->data = newIBoot; } //check for size and availability size_t newPaddedDataLen=0; size_t totalBytes=0; //if somebody can find how to get padded length for new ibot maybe this loop not needed while(verify != NULL) { cur = verify; verify = verify->next; AppleImg3RootHeader* header = (AppleImg3RootHeader*) cur->data; totalBytes += header->base.size; if(cur->type == newFourcc) { newPaddedDataLen = header->base.size; } } bufferPrintf("Total size to be written %d\r\n",totalBytes); if((ImagesStart + totalBytes) >= 0xfc000) { bufferPrintf("**ABORTED** Writing total image size: 0x%x, new ibot size: 0x%x at 0x%x would overflow NOR!\r\n", totalBytes, newPaddedDataLen,ImagesStart); images_rewind(); images_release(); images_setup(); return; } bufferPrintf("Flashing...\r\n"); images_rewind(); while(list != NULL) { cur = list; list = list->next; AppleImg3RootHeader* header = (AppleImg3RootHeader*) cur->data; bufferPrintf("Flashing: "); print_fourcc(cur->type); bufferPrintf(" (%x, %d bytes)\r\n", cur->data, header->base.size); images_append(cur->data, header->base.size); free(cur->data); free(cur); } bufferPrintf("Flashing Complete, Free space after flashing %d\r\n",0xfc000-MaxOffset); images_release(); images_setup(); bufferPrintf("Configuring openiBoot settings...\r\n"); Volume* volume; io_func* io; io = bdev_open(0); volume = openVolume(io); char buffer [sizeof(XSTRINGIFY(OPENIBOOT_VERSION))]; strcpy(buffer, XSTRINGIFY(OPENIBOOT_VERSION)); add_hfs(volume, (uint8_t*)buffer, sizeof(buffer), "/openiboot"); closeVolume(volume); CLOSE(io); ftl_sync(); if(!nvram_getvar("opib-temp-os")) { nvram_setvar("opib-temp-os", "0"); } if(!nvram_getvar("opib-default-os")) { nvram_setvar("opib-default-os", "1"); } if(!nvram_getvar("opib-menu-timeout")) { nvram_setvar("opib-menu-timeout", "10000"); } nvram_save(); bufferPrintf("openiBoot installation complete.\r\n"); }
void startScripting(char* loadedFrom) { uint32_t size = 0; uint8_t* address = NULL; const char* partitionScript = nvram_getvar("partition-script"); /*get the partition where the script is in NVRAM*/ const char* fileScript = nvram_getvar("file-script"); /*get the path to the file script in NVRAM*/ const char* scriptingLinux = nvram_getvar("scripting-linux"); /*tells whether to run the script before booting linux. Accepted values : true or 1, anything else if false*/ const char* scriptingOpeniboot = nvram_getvar("scripting-openiboot"); /*tells whether to run the script before launching openiboot console. Accepted values : true or 1, anything else if false*/ //uint32_t numberOfLines = 1; /*number of lines in the script files - To be used with the next commented section of code for debug*/ //bufferPrintf("partition-script %s\r\n",partitionScript); /*For debug*/ //bufferPrintf("file-script %s\r\n",fileScript); /*For debug*/ if(!partitionScript) return; if(!fileScript) return; /* ------ extracting the script file at address 0x09000000 ----- */ if(strcmp(loadedFrom, "linux") == 0) { if(!scriptingLinux || (strcmp(scriptingLinux, "true") != 0 && strcmp(scriptingLinux, "1") != 0)) { return; /* terminate the function if scripting is not asked*/ } } if(strcmp(loadedFrom, "openiboot") == 0) { if(!scriptingOpeniboot || (strcmp(scriptingOpeniboot, "true") != 0 && strcmp(scriptingOpeniboot, "1") != 0)) { return; /* terminate the function if scripting is not asked*/ } } Volume* volume; io_func* io; io = bdev_open(parseNumber(partitionScript)); if(io == NULL) { bufferPrintf("fs: cannot read partition!\r\n"); return; } volume = openVolume(io); if(volume == NULL) { bufferPrintf("fs: cannot openHFS volume!\r\n"); return; } HFSPlusCatalogRecord* record; char* name; record = getRecordFromPath(fileScript, volume, &name, NULL); if(record != NULL) { if(record->recordType == kHFSPlusFolderRecord) { bufferPrintf("this path is a folder, not a file\r\n"); return; } else { size = readHFSFile((HFSPlusCatalogFile*)record, &address, volume); if(!address) return; //bufferPrintf("size = %d\r\n",size); /*size of script file, used later*/ } } else { bufferPrintf("No such file or directory\r\n"); return; } closeVolume(volume); CLOSE(io); char* addrBOF = (char*) address; /* pointer on the begening of the file*/ char* addrEOF = (char*) (address + size); /*pointer 1 byte after the file */ char* addr; /*pointer on the current space on memory*/ #if 0 //addrEOF = (void*)address+size+1; /* ----- counting how many lines are present in the script file by the '\n' ----- */ addr = addrBOF; while(addr < addrEOF) { if(*addr=='\r'){ numberOfLines++; } addr++; } bufferPrintf("number of lines : %d\r\n", numberOfLines); #endif char* bufferLine = malloc(100); /* ----- extracting each line to the buffer -----*/ addr = addrBOF; while(addr < addrEOF) { int charAt = 0; while((*addr != '\n') && (addr < addrEOF)) { if(*addr != '\r') { bufferLine[charAt] = *addr; //bufferPrintf("reading char : %c\r\n",*addr); charAt++; } addr++; } bufferLine[charAt]='\0'; bufferPrintf("\r\n%s\r\n", bufferLine); bufferLine[charAt]='\n'; bufferLine[charAt + 1] = '\0'; if(scriptCommand(bufferLine)) { //bufferPrintf("command sent\r\n"); } /*else { //error in command, function scriptCommand returned false }*/ addr++; } free(bufferLine); free(address); }
int zuluCryptRunTest( void ) { uid_t uid = getuid() ; seteuid( 0 ) ; setgid( uid ) ; setgroups( 1,&uid ) ; setegid( uid ) ; setuid( uid ) ; if( _loop_device_module_is_not_present() ){ printf( "\nWARNING: \"loop\" kernel module does not appear to be loaded\n" ) ; printf( "tests and opening of encrypted containers in files will fail if the module was not built into the kernel\n\n" ) ; } createTestImages() ; createKeyFiles() ; __printLine() ; createVolume( luksTestVolume,"create a luks type volume using a key: ","-p","luks" ) ; __printLine() ; checkIfDeviceIsLuks( luksTestVolume ) ; __printLine() ; createHeaderBackup( luksTestVolume,"create luks header backup: " ) ; __printLine() ; restoreHeaderBackup( luksTestVolume,"restore luks header from backup: " ) ; __printLine() ; createVolume( plainTestVolume,"create a plain type volume using a key: ","-p","plain" ) ; __printLine() ; openVolume( plainTestVolume,"open a plain volume with a key: ","-p" ); closeVolume( plainTestVolume,"closing a plain volume: " ) ; __printLine() ; openVolume( plainTestVolume,"open a plain volume with a keyfile: ","-f" ); closeVolume( plainTestVolume,"closing a plain volume: " ) ; __printLine() ; openVolumeWithPlugIn( plainTestVolume,"open a plain volume using a plugin: " ) ; closeVolume( plainTestVolume,"closing a plain volume: " ) ; __printLine() ; openVolume( luksTestVolume,"open a luks volume with a key: ","-p" ); closeVolume( luksTestVolume,"closing a luks volume: " ) ; __printLine() ; openVolume( luksTestVolume,"open a luks volume with a keyfile: ","-f" ); closeVolume( luksTestVolume,"closing a luks volume: " ) ; __printLine() ; openVolumeWithPlugIn( luksTestVolume,"open a luks volume using a plugin: " ) ; closeVolume( luksTestVolume,"closing a luks volume: " ) ; __printLine() ; checkKeySlotsInUse( luksTestVolume ) ; __printLine() ; addKeysToLuks( luksTestVolume ) ; __printLine() ; checkKeySlotsInUse( luksTestVolume ) ; __printLine() ; removeKeysFromLuksVolume( luksTestVolume ) ; checkKeySlotsInUse( luksTestVolume ) ; __printLine() ; checkForOpenedMappers() ; EXIT( 0,NULL ) ; return 0 ; }
int main(int argc, const char *argv[]) { io_func* io; Volume* volume; AbstractFile* image; int argOff; TestByteOrder(); if(argc < 3) { printf("usage: %s <image-file> (-k <key>) <ls|cat|mv|mkdir|add|rm|chmod|extract|extractall|rmall|addall|grow|untar> <arguments>\n", argv[0]); return 0; } argOff = 2; if(strstr(argv[1], ".dmg")) { image = createAbstractFileFromFile(fopen(argv[1], "rb")); if(argc > 3) { if(strcmp(argv[2], "-k") == 0) { image = createAbstractFileFromFileVault(image, argv[3]); argOff = 4; } } io = openDmgFilePartition(image, -1); } else { io = openFlatFile(argv[1]); } if(io == NULL) { fprintf(stderr, "error: Cannot open image-file.\n"); return 1; } volume = openVolume(io); if(volume == NULL) { fprintf(stderr, "error: Cannot open volume.\n"); CLOSE(io); return 1; } if(argc > argOff) { if(strcmp(argv[argOff], "ls") == 0) { cmd_ls(volume, argc - argOff, argv + argOff); } else if(strcmp(argv[argOff], "cat") == 0) { cmd_cat(volume, argc - argOff, argv + argOff); } else if(strcmp(argv[argOff], "mv") == 0) { cmd_mv(volume, argc - argOff, argv + argOff); } else if(strcmp(argv[2], "symlink") == 0) { cmd_symlink(volume, argc - 2, argv + 2); } else if(strcmp(argv[argOff], "mkdir") == 0) { cmd_mkdir(volume, argc - argOff, argv + argOff); } else if(strcmp(argv[argOff], "add") == 0) { cmd_add(volume, argc - argOff, argv + argOff); } else if(strcmp(argv[argOff], "rm") == 0) { cmd_rm(volume, argc - argOff, argv + argOff); } else if(strcmp(argv[argOff], "chmod") == 0) { cmd_chmod(volume, argc - argOff, argv + argOff); } else if(strcmp(argv[argOff], "extract") == 0) { cmd_extract(volume, argc - argOff, argv + argOff); } else if(strcmp(argv[argOff], "extractall") == 0) { cmd_extractall(volume, argc - argOff, argv + argOff); } else if(strcmp(argv[argOff], "rmall") == 0) { cmd_rmall(volume, argc - argOff, argv + argOff); } else if(strcmp(argv[argOff], "addall") == 0) { cmd_addall(volume, argc - argOff, argv + argOff); } else if(strcmp(argv[argOff], "grow") == 0) { cmd_grow(volume, argc - argOff, argv + argOff); } else if(strcmp(argv[argOff], "untar") == 0) { cmd_untar(volume, argc - argOff, argv + argOff); } } closeVolume(volume); CLOSE(io); return 0; }