int main(int argc, char* argv[]) {
int result = 0;
if (argc != 3) {
usage();
}
const char* ibssFile = argv[1];
const char* kernelcacheFile = argv[2];
pois0n_init();
pois0n_set_callback(&print_progress, NULL);
info("Waiting for device to enter DFU mode\n");
while(pois0n_is_ready()) {
sleep(1);
}
info("Found device in DFU mode\n");
result = pois0n_is_compatible();
if (result < 0) {
error("Your device in incompatible with this exploit!\n");
return result;
}
result = pois0n_injectonly();
if (result < 0) {
error("Exploit injection failed!\n");
return result;
}
debug("Uploading %s to device\n", ibssFile);
irecv_error_t error = irecv_send_file(client, ibssFile, 1);
if(error != IRECV_E_SUCCESS) {
error("Unable to upload iBSS\n");
debug("%s\n", irecv_strerror(error));
return -1;
}
client = irecv_reconnect(client, 10);
debug("Uploading %s to device\n", kernelcacheFile);
error = irecv_send_file(client, kernelcacheFile, 1);
if(error != IRECV_E_SUCCESS) {
error("Unable to upload kernelcache\n");
debug("%s\n", irecv_strerror(error));
return -1;
}
error = irecv_send_command(client, "bootx");
if(error != IRECV_E_SUCCESS) {
error("Unable send the bootx command\n");
return -1;
}
pois0n_exit();
return 0;
}
int upload_kernelcache() {
struct stat buf;
char kernelcache[255];
irecv_error_t error = IRECV_E_SUCCESS;
memset(kernelcache, '\0', 255);
memset(&buf, '\0', sizeof(buf));
snprintf(kernelcache, 254, "kernelcache.release.%c%c%c", device->model[0], device->model[1], device->model[2]);
debug("Checking if kernelcache already exists\n");
if (stat(kernelcache, &buf) != 0) {
if (fetch_image(kernelcache, kernelcache) < 0) {
error("Unable to upload kernelcache\n");
return -1;
}
}
debug("Resetting device counters\n");
error = irecv_reset_counters(client);
if (error != IRECV_E_SUCCESS) {
debug("%s\n", irecv_strerror(error));
error("Unable upload kernelcache\n");
return -1;
}
error = irecv_send_file(client, kernelcache, 1);
if (error != IRECV_E_SUCCESS) {
debug("%s\n", irecv_strerror(error));
error("Unable upload kernelcache\n");
return -1;
}
return 0;
}
int upload_firmware_image(const char* type) {
char image[255];
struct stat buf;
irecv_error_t error = IRECV_E_SUCCESS;
memset(image, '\0', 255);
snprintf(image, 254, "%s.%s", type, device->model);
debug("Checking if %s already exists\n", image);
if (stat(image, &buf) != 0) {
if (fetch_firmware_image(type, image) < 0) {
error("Unable to upload firmware image\n");
return -1;
}
}
debug("Resetting device counters\n");
error = irecv_reset_counters(client);
if (error != IRECV_E_SUCCESS) {
error("Unable to upload firmware image\n");
debug("%s\n", irecv_strerror(error));
return -1;
}
debug("Uploading %s to device\n", image);
error = irecv_send_file(client, image, 1);
if (error != IRECV_E_SUCCESS) {
error("Unable to upload firmware image\n");
debug("%s\n", irecv_strerror(error));
return -1;
}
return 0;
}
void parse_command(irecv_client_t client, unsigned char* command, unsigned int size) {
char* cmd = strdup(command);
char* action = strtok(cmd, " ");
debug("Executing %s\n", action);
if (!strcmp(cmd, "/exit")) {
quit = 1;
} else
if (!strcmp(cmd, "/help")) {
shell_usage();
} else
if (!strcmp(cmd, "/upload")) {
char* filename = strtok(NULL, " ");
debug("Uploading files %s\n", filename);
if (filename != NULL) {
irecv_send_file(client, filename, 0);
}
} else
if (!strcmp(cmd, "/deviceinfo")) {
int ret;
unsigned int cpid, bdid;
unsigned long long ecid;
unsigned char srnm[12], imei[15], bt[15];
ret = irecv_get_cpid(client, &cpid);
if(ret == IRECV_E_SUCCESS) {
printf("CPID: %d\n", cpid);
}
ret = irecv_get_bdid(client, &bdid);
if(ret == IRECV_E_SUCCESS) {
printf("BDID: %d\n", bdid);
}
ret = irecv_get_ecid(client, &ecid);
if(ret == IRECV_E_SUCCESS) {
printf("ECID: %lld\n", ecid);
}
ret = irecv_get_srnm(client, srnm);
if(ret == IRECV_E_SUCCESS) {
printf("SRNM: %s\n", srnm);
}
ret = irecv_get_imei(client, imei);
if(ret == IRECV_E_SUCCESS) {
printf("IMEI: %s\n", imei);
}
} else
if (!strcmp(cmd, "/exploit")) {
char* filename = strtok(NULL, " ");
debug("Sending exploit %s\n", filename);
if (filename != NULL) {
irecv_send_file(client, filename, 0);
}
irecv_send_exploit(client);
} else
if (!strcmp(cmd, "/execute")) {
char* filename = strtok(NULL, " ");
debug("Executing script %s\n", filename);
if (filename != NULL) {
irecv_execute_script(client, filename);
}
}
free(action);
}
int main(int argc, char* argv[]) {
int i = 0;
int opt = 0;
int action = 0;
char* argument = NULL;
irecv_error_t error = 0;
if (argc == 1) print_usage();
while ((opt = getopt(argc, argv, "vhrsc:f:e:k::")) > 0) {
switch (opt) {
case 'v':
verbose += 1;
break;
case 'h':
print_usage();
break;
case 'r':
action = kResetDevice;
break;
case 's':
action = kStartShell;
break;
case 'f':
action = kSendFile;
argument = optarg;
break;
case 'c':
action = kSendCommand;
argument = optarg;
break;
case 'k':
action = kSendExploit;
argument = optarg;
break;
case 'e':
action = kSendScript;
argument = optarg;
break;
default:
fprintf(stderr, "Unknown argument\n");
return -1;
}
}
if (verbose) irecv_set_debug_level(verbose);
irecv_init();
irecv_client_t client = NULL;
for (i = 0; i <= 5; i++) {
debug("Attempting to connect... \n");
if (irecv_open(&client) != IRECV_E_SUCCESS)
sleep(1);
else
break;
if (i == 5) {
return -1;
}
}
switch (action) {
case kResetDevice:
irecv_reset(client);
break;
case kSendFile:
irecv_event_subscribe(client, IRECV_PROGRESS, &progress_cb, NULL);
error = irecv_send_file(client, argument, 1);
debug("%s\n", irecv_strerror(error));
break;
case kSendCommand:
error = irecv_send_command(client, argument);
debug("%s\n", irecv_strerror(error));
break;
case kSendExploit:
if (argument != NULL) {
irecv_event_subscribe(client, IRECV_PROGRESS, &progress_cb, NULL);
error = irecv_send_file(client, argument, 0);
if (error != IRECV_E_SUCCESS) {
debug("%s\n", irecv_strerror(error));
break;
}
}
error = irecv_send_exploit(client);
debug("%s\n", irecv_strerror(error));
break;
case kStartShell:
init_shell(client);
break;
case kSendScript:
error = irecv_execute_script(client, argument);
if(error != IRECV_E_SUCCESS) {
debug("%s\n", irecv_strerror(error));
}
break;
default:
fprintf(stderr, "Unknown action\n");
break;
}
irecv_close(client);
return 0;
}
int tethered_boot(const char *ibssFile, const char *ibecFile, const char *kernelcacheFile, const char *ramdiskFile, const char *devicetreeFile)
{
int result = 0;
irecv_error_t ir_error = IRECV_E_SUCCESS;
irecv_client_t client = g_syringe_client;
libpois0n_debug = 1;
pois0n_init();
info("Waiting for device to enter DFU mode\n");
while(pois0n_is_ready()) {
sleep(1);
}
info("Found device in DFU mode\n");
result = pois0n_is_compatible();
if (result < 0) {
error("Your device in incompatible with this exploit!\n");
goto cleanup;
}
result = pois0n_injectonly();
if (result < 0) {
error("Exploit injection failed!\n");
goto cleanup;
}
client = g_syringe_client;
if (ibssFile != NULL) {
debug("Uploading %s to device, mode: 0x%x\n", ibssFile, client->mode);
ir_error = irecv_send_file(client, ibssFile, 1);
if(ir_error != IRECV_E_SUCCESS) {
error("Unable to upload iBSS\n");
debug("%s\n", irecv_strerror(ir_error));
result = -1;
goto cleanup;
}
sleep(10);
} else {
error("ibss can't be null\n");
result = -1;
goto cleanup;
}
if (ibecFile != NULL) {
client = g_syringe_client = irecv_reconnect(client, 10);
debug("Uploading iBEC %s to device, mode: 0x%x\n", ibecFile, client->mode);
ir_error = irecv_send_file(client, ibecFile, 1);
if(ir_error != IRECV_E_SUCCESS) {
error("Unable to upload iBEC\n");
debug("%s\n", irecv_strerror(ir_error));
result = -1;
goto cleanup;
}
sleep(5);
}
client = g_syringe_client = irecv_reconnect(client, 10);
if (ramdiskFile != NULL) {
debug("Uploading ramdisk %s to device\n", ramdiskFile);
ir_error = irecv_send_file(client, ramdiskFile, 1);
if(ir_error != IRECV_E_SUCCESS) {
error("Unable to upload ramdisk\n");
debug("%s\n", irecv_strerror(ir_error));
result = -1;
goto cleanup;
}
sleep(5);
ir_error = irecv_send_command(client, "ramdisk");
if(ir_error != IRECV_E_SUCCESS) {
error("Unable send the ramdisk command\n");
result = -1;
goto cleanup;
}
}
if (devicetreeFile != NULL) {
debug("Uploading device tree %s to device\n", devicetreeFile);
ir_error = irecv_send_file(client, devicetreeFile, 1);
if(ir_error != IRECV_E_SUCCESS) {
error("Unable to upload device tree\n");
debug("%s\n", irecv_strerror(ir_error));
result = -1;
goto cleanup;
}
ir_error = irecv_send_command(client, "devicetree");
if(ir_error != IRECV_E_SUCCESS) {
error("Unable to send the devicetree command\n");
result = -1;
goto cleanup;
}
}
if (kernelcacheFile != NULL) {
debug("Uploading kernel %s to device, mode: 0x%x\n", kernelcacheFile, client->mode);
ir_error = irecv_send_file(client, kernelcacheFile, 1);
if(ir_error != IRECV_E_SUCCESS) {
error("Unable to upload kernelcache\n");
debug("%s\n", irecv_strerror(ir_error));
result = -1;
goto cleanup;
}
ir_error = irecv_send_command(client, "bootx");
if(ir_error != IRECV_E_SUCCESS) {
error("Unable send the bootx command\n");
result = -1;
goto cleanup;
}
} else {
error("kernelcache can't be null\n");
result = -1;
goto cleanup;
}
result = 0;
cleanup:
fflush(stderr);
if (g_syringe_client) {
irecv_close(&g_syringe_client);
g_syringe_client = NULL;
}
//pois0n_exit();
return result;
}
int main(int argc, char* argv[]) {
int result = 0;
irecv_error_t ir_error = IRECV_E_SUCCESS;
//int index;
const char
*ibssFile = NULL,
*ibecFile = NULL,
*kernelcacheFile = NULL,
*ramdiskFile = NULL,
*bgcolor = NULL,
*bootlogo = NULL;
int c;
opterr = 0;
while ((c = getopt (argc, argv, "vhi:b:k:r:l:c:")) != -1)
switch (c)
{
case 'v':
g_verbose = true;
break;
case 'h':
usage();
break;
case 'i':
if (!file_exists(optarg)) {
error("Cannot open iBSS file '%s'\n", optarg);
return -1;
}
ibssFile = optarg;
break;
case 'b':
if (!file_exists(optarg)) {
error("Cannot open iBEC file '%s'\n", optarg);
return -1;
}
ibecFile = optarg;
break;
case 'k':
if (!file_exists(optarg)) {
error("Cannot open kernelcache file '%s'\n", optarg);
return -1;
}
kernelcacheFile = optarg;
break;
case 'r':
if (!file_exists(optarg)) {
error("Cannot open ramdisk file '%s'\n", optarg);
return -1;
}
ramdiskFile = optarg;
break;
case 'l':
if (!file_exists(optarg)) {
error("Cannot open bootlogo file '%s'\n", optarg);
return -1;
}
bootlogo = optarg;
break;
case 'c':
bgcolor = optarg;
break;
default:
usage();
}
pois0n_init();
pois0n_set_callback(&print_progress, NULL);
info("Waiting for device to enter DFU mode\n");
while(pois0n_is_ready()) {
sleep(1);
}
info("Found device in DFU mode\n");
result = pois0n_is_compatible();
if (result < 0) {
error("Your device in incompatible with this exploit!\n");
return result;
}
result = pois0n_injectonly();
if (result < 0) {
error("Exploit injection failed!\n");
return result;
}
if (ibssFile != NULL) {
debug("Uploading %s to device\n", ibssFile);
ir_error = irecv_send_file(g_syringe_client, ibssFile, 1);
if(ir_error != IRECV_E_SUCCESS) {
error("Unable to upload iBSS\n");
debug("%s\n", irecv_strerror(ir_error));
return -1;
}
sleep(10);
} else {
return 0;
}
if (ibecFile != NULL) {
g_syringe_client = irecv_reconnect(g_syringe_client, 10);
debug("Uploading iBEC %s to device\n", ibecFile);
ir_error = irecv_send_file(g_syringe_client, ibecFile, 1);
if(ir_error != IRECV_E_SUCCESS) {
error("Unable to upload iBEC\n");
debug("%s\n", irecv_strerror(ir_error));
return -1;
}
sleep(5);
}
g_syringe_client = irecv_reconnect(g_syringe_client, 10);
if (ramdiskFile != NULL) {
debug("Uploading ramdisk %s to device\n", ramdiskFile);
ir_error = irecv_send_file(g_syringe_client, ramdiskFile, 1);
if(ir_error != IRECV_E_SUCCESS) {
error("Unable to upload ramdisk\n");
debug("%s\n", irecv_strerror(ir_error));
return -1;
}
sleep(5);
ir_error = irecv_send_command(g_syringe_client, "ramdisk");
if(ir_error != IRECV_E_SUCCESS) {
error("Unable send the ramdisk command\n");
return -1;
}
}
if (bootlogo != NULL) {
debug("Uploading boot logo %s to device\n", bootlogo);
ir_error = irecv_send_file(g_syringe_client, bootlogo, 1);
if(ir_error != IRECV_E_SUCCESS) {
error("Unable to upload bootlogo\n");
debug("%s\n", irecv_strerror(ir_error));
return -1;
}
ir_error = irecv_send_command(g_syringe_client, "setpicture 1");
if(ir_error != IRECV_E_SUCCESS) {
error("Unable to set picture\n");
return -1;
}
ir_error = irecv_send_command(g_syringe_client, "bgcolor 0 0 0");
if(ir_error != IRECV_E_SUCCESS) {
error("Unable to set picture\n");
return -1;
}
}
if (bgcolor != NULL) {
char finalbgcolor[255];
sprintf(finalbgcolor, "bgcolor %s", bgcolor);
ir_error = irecv_send_command(g_syringe_client, finalbgcolor);
if(ir_error != IRECV_E_SUCCESS) {
error("Unable set bgcolor\n");
return -1;
}
}
if (kernelcacheFile != NULL) {
debug("Uploading %s to device\n", kernelcacheFile);
ir_error = irecv_send_file(g_syringe_client, kernelcacheFile, 1);
if(ir_error != IRECV_E_SUCCESS) {
error("Unable to upload kernelcache\n");
debug("%s\n", irecv_strerror(ir_error));
return -1;
}
ir_error = irecv_send_command(g_syringe_client, "bootx");
if(ir_error != IRECV_E_SUCCESS) {
error("Unable send the bootx command\n");
return -1;
}
}
pois0n_exit();
return 0;
}
int main(int argc, char* argv[]) {
int i = 0;
int opt = 0;
int action = 0;
unsigned long long ecid = 0;
int mode = -1;
char* argument = NULL;
irecv_error_t error = 0;
char* buffer = NULL;
uint64_t buffer_length = 0;
if (argc == 1) {
print_usage(argc, argv);
return 0;
}
while ((opt = getopt(argc, argv, "i:vhrsmnc:f:e:k::")) > 0) {
switch (opt) {
case 'i':
if (optarg) {
char* tail = NULL;
ecid = strtoull(optarg, &tail, 16);
if (tail && (tail[0] != '\0')) {
ecid = 0;
}
if (ecid == 0) {
fprintf(stderr, "ERROR: Could not parse ECID from argument '%s'\n", optarg);
return -1;
}
}
break;
case 'v':
verbose += 1;
break;
case 'h':
print_usage(argc, argv);
return 0;
case 'm':
action = kShowMode;
break;
case 'n':
action = kRebootToNormalMode;
break;
case 'r':
action = kResetDevice;
break;
case 's':
action = kStartShell;
break;
case 'f':
action = kSendFile;
argument = optarg;
break;
case 'c':
action = kSendCommand;
argument = optarg;
break;
case 'k':
action = kSendExploit;
argument = optarg;
break;
case 'e':
action = kSendScript;
argument = optarg;
break;
default:
fprintf(stderr, "Unknown argument\n");
return -1;
}
}
if (verbose)
irecv_set_debug_level(verbose);
irecv_init();
irecv_client_t client = NULL;
for (i = 0; i <= 5; i++) {
debug("Attempting to connect... \n");
if (irecv_open_with_ecid(&client, ecid) != IRECV_E_SUCCESS)
sleep(1);
else
break;
if (i == 5) {
return -1;
}
}
irecv_device_t device = NULL;
irecv_devices_get_device_by_client(client, &device);
if (device)
debug("Connected to %s, model %s, cpid 0x%04x, bdid 0x%02x\n", device->product_type, device->hardware_model, device->chip_id, device->board_id);
switch (action) {
case kResetDevice:
irecv_reset(client);
break;
case kSendFile:
irecv_event_subscribe(client, IRECV_PROGRESS, &progress_cb, NULL);
error = irecv_send_file(client, argument, 1);
debug("%s\n", irecv_strerror(error));
break;
case kSendCommand:
error = irecv_send_command(client, argument);
debug("%s\n", irecv_strerror(error));
break;
case kSendExploit:
if (argument != NULL) {
irecv_event_subscribe(client, IRECV_PROGRESS, &progress_cb, NULL);
error = irecv_send_file(client, argument, 0);
if (error != IRECV_E_SUCCESS) {
debug("%s\n", irecv_strerror(error));
break;
}
}
error = irecv_trigger_limera1n_exploit(client);
debug("%s\n", irecv_strerror(error));
break;
case kStartShell:
init_shell(client);
break;
case kSendScript:
buffer_read_from_filename(argument, &buffer, &buffer_length);
if (buffer) {
buffer[buffer_length] = '\0';
error = irecv_execute_script(client, buffer);
if(error != IRECV_E_SUCCESS) {
debug("%s\n", irecv_strerror(error));
}
free(buffer);
} else {
fprintf(stderr, "Could not read file '%s'\n", argument);
}
break;
case kShowMode:
irecv_get_mode(client, &mode);
printf("%s Mode\n", mode_to_str(mode));
break;
case kRebootToNormalMode:
error = irecv_setenv(client, "auto-boot", "true");
if (error != IRECV_E_SUCCESS) {
debug("%s\n", irecv_strerror(error));
break;
}
error = irecv_saveenv(client);
if (error != IRECV_E_SUCCESS) {
debug("%s\n", irecv_strerror(error));
break;
}
error = irecv_reboot(client);
if (error != IRECV_E_SUCCESS) {
debug("%s\n", irecv_strerror(error));
} else {
debug("%s\n", irecv_strerror(error));
}
break;
default:
fprintf(stderr, "Unknown action\n");
break;
}
irecv_close(client);
return 0;
}
static void parse_command(irecv_client_t client, unsigned char* command, unsigned int size) {
char* cmd = strdup((char*)command);
char* action = strtok(cmd, " ");
if (!strcmp(cmd, "/exit")) {
quit = 1;
} else if (!strcmp(cmd, "/help")) {
shell_usage();
} else if (!strcmp(cmd, "/upload")) {
char* filename = strtok(NULL, " ");
debug("Uploading files %s\n", filename);
if (filename != NULL) {
irecv_send_file(client, filename, 0);
}
} else if (!strcmp(cmd, "/deviceinfo")) {
int ret, mode;
unsigned int cpid, bdid;
unsigned long long ecid;
char srnm[12], imei[15];
ret = irecv_get_cpid(client, &cpid);
if(ret == IRECV_E_SUCCESS) {
printf("CPID: %d\n", cpid);
}
ret = irecv_get_bdid(client, &bdid);
if(ret == IRECV_E_SUCCESS) {
printf("BDID: %d\n", bdid);
}
ret = irecv_get_ecid(client, &ecid);
if(ret == IRECV_E_SUCCESS) {
printf("ECID: " _FMT_lld "\n", ecid);
}
ret = irecv_get_srnm(client, srnm);
if(ret == IRECV_E_SUCCESS) {
printf("SRNM: %s\n", srnm);
}
ret = irecv_get_imei(client, imei);
if(ret == IRECV_E_SUCCESS) {
printf("IMEI: %s\n", imei);
}
ret = irecv_get_mode(client, &mode);
if (ret == IRECV_E_SUCCESS) {
printf("MODE: %s\n", mode_to_str(mode));
}
} else if (!strcmp(cmd, "/limera1n")) {
char* filename = strtok(NULL, " ");
debug("Sending limera1n payload %s\n", filename);
if (filename != NULL) {
irecv_send_file(client, filename, 0);
}
irecv_trigger_limera1n_exploit(client);
} else if (!strcmp(cmd, "/execute")) {
char* filename = strtok(NULL, " ");
debug("Executing script %s\n", filename);
if (filename != NULL) {
char* buffer = NULL;
uint64_t buffer_length = 0;
buffer_read_from_filename(filename, &buffer, &buffer_length);
if (buffer) {
buffer[buffer_length] = '\0';
irecv_execute_script(client, buffer);
free(buffer);
} else {
printf("Could not read file '%s'\n", filename);
}
}
}
free(action);
}
static void parse_command(irecv_client_t client, unsigned char* command, unsigned int size) {
char* cmd = strdup((char*)command);
char* action = strtok(cmd, " ");
if (!strcmp(cmd, "/exit")) {
quit = 1;
} else if (!strcmp(cmd, "/help")) {
shell_usage();
} else if (!strcmp(cmd, "/upload")) {
char* filename = strtok(NULL, " ");
debug("Uploading file %s\n", filename);
if (filename != NULL) {
irecv_send_file(client, filename, 0);
}
} else if (!strcmp(cmd, "/deviceinfo")) {
int ret, mode;
const struct irecv_device_info *devinfo = irecv_get_device_info(client);
if (devinfo) {
printf("CPID: %04x\n", devinfo->cpid);
printf("CPRV: %02x\n", devinfo->cprv);
printf("BDID: %02x\n", devinfo->bdid);
printf("ECID: " _FMT_lld "\n", devinfo->ecid);
printf("CPFM: %02x\n", devinfo->cpfm);
printf("SCEP: %02x\n", devinfo->scep);
printf("IBFL: %02x\n", devinfo->ibfl);
printf("SRNM: %s\n", (devinfo->srnm) ? devinfo->srnm : "N/A");
printf("IMEI: %s\n", (devinfo->imei) ? devinfo->imei : "N/A");
} else {
printf("Could not get device info?!\n");
}
ret = irecv_get_mode(client, &mode);
if (ret == IRECV_E_SUCCESS) {
printf("MODE: %s\n", mode_to_str(mode));
}
} else if (!strcmp(cmd, "/limera1n")) {
char* filename = strtok(NULL, " ");
debug("Sending limera1n payload %s\n", filename);
if (filename != NULL) {
irecv_send_file(client, filename, 0);
}
irecv_trigger_limera1n_exploit(client);
} else if (!strcmp(cmd, "/execute")) {
char* filename = strtok(NULL, " ");
debug("Executing script %s\n", filename);
if (filename != NULL) {
char* buffer = NULL;
uint64_t buffer_length = 0;
buffer_read_from_filename(filename, &buffer, &buffer_length);
if (buffer) {
buffer[buffer_length] = '\0';
irecv_execute_script(client, buffer);
free(buffer);
} else {
printf("Could not read file '%s'\n", filename);
}
}
} else {
printf("Unsupported command %s. Use /help to get a list of available commands.\n", cmd);
}
free(action);
}
int main(int argc, char* argv[])
{
irecv_error_t error;
unsigned int cpid;
int can_ra1n = 0;
printf("Loadibec " LOADIBEC_VERSION COMMIT_STRING ".\n");
if(argc != 2)
{
printf("Usage: %s <file>\n"
"\tLoads a file to an iDevice in recovery mode and jumps to it.\n", argv[0]);
return 0;
}
irecv_init();
printf("Connecting to iDevice...\n");
error = irecv_open_attempts(&g_syringe_client, 10);
if(error != IRECV_E_SUCCESS)
{
fprintf(stderr, "Failed to connect to iBoot, error %d.\n", error);
return -error;
}
if(irecv_get_cpid(g_syringe_client, &cpid) == IRECV_E_SUCCESS)
{
if(cpid > 8900)
can_ra1n = 1;
}
if(g_syringe_client->mode == kDfuMode && can_ra1n)
{
int ret;
printf("linera1n compatible device detected, injecting limera1n.\n");
irecv_close(&g_syringe_client);
irecv_exit();
pois0n_init();
ret = pois0n_is_ready();
if(ret < 0)
return ret;
ret = pois0n_is_compatible();
if(ret < 0)
return ret;
pois0n_inject();
irecv_close(&g_syringe_client);
g_syringe_client = NULL;
printf("limera1ned, reconnecting...\n");
g_syringe_client = irecv_reconnect(g_syringe_client, 10);
if(!g_syringe_client)
{
fprintf(stderr, "Failed to reconnect.\n");
return 4;
}
}
else
can_ra1n = 0;
printf("Starting transfer of '%s'.\n", argv[1]);
irecv_event_subscribe(g_syringe_client, IRECV_PROGRESS, &progress_cb, NULL);
error = irecv_send_file(g_syringe_client, argv[1], 0);
if(error != IRECV_E_SUCCESS)
{
fprintf(stderr, "Failed to upload '%s', error %d.\n", argv[1], error);
return 2;
}
error = irecv_send_command(g_syringe_client, "go");
if(error != IRECV_E_SUCCESS)
{
fprintf(stderr, "Failed to jump to uploaded file, error %d.\n", error);
return 3;
}
irecv_send_command(g_syringe_client, "go jump 0x41000000");
printf("Uploaded Successfully.\n");
irecv_exit();
return 0;
}