int main(int argc, char* argv[]) {
u8* data;
u8 sha_key[0x40];
if(argc < 2) {
printf("usage: %s my.pkg\n", argv[0]);
return -1;
}
int i;
FILE *f=fopen(argv[1], "rb");
fseek(f, 0, SEEK_END);
int nlen = ftell(f);
fseek(f, 0, SEEK_SET);
data = (u8*)malloc(nlen);
fread(data, 1, nlen, f);
fclose(f);
pkg_header *header = (pkg_header *)data;
int data_offset = get_u64(&(header->dataOffset));
int data_size = get_u64(&(header->dataSize));
// decrypt debug
u8 sha_crap[0x40];
memset(sha_crap, 0, 0x40);
memcpy(sha_crap, &data[0x60], 8);
memcpy(sha_crap+0x8, &data[0x60], 8);
memcpy(sha_crap+0x10, &data[0x68], 8);
memcpy(sha_crap+0x18, &data[0x68], 8);
int dptr;
for(dptr = data_offset; dptr < (data_offset+data_size); dptr+=0x10) {
u8 hash[0x14];
SHA1(sha_crap, 0x40, hash);
for(i=0; i<0x10; i++) data[dptr+i] ^= hash[i];
set_u64(sha_crap+0x38, get_u64(sha_crap+0x38)+1);
}
// recrypt retail
u8 pkg_key[0x10];
memcpy(pkg_key, &data[0x70], 0x10);
AES_KEY aes_key;
AES_set_encrypt_key(retail_pkg_aes_key, 128, &aes_key);
int num=0;
u8 ecount_buf[0x10];
memset(ecount_buf, 0, 0x10);
AES_ctr128_encrypt(&data[data_offset], &data[data_offset], data_size, &aes_key, pkg_key, ecount_buf, &num);
// write back
FILE *g = fopen(argv[1], "wb");
data[4] = 0x80; // set finalize flag
memset(&data[(data_offset+data_size)], 0, 0x60);
// add hash
SHA1(data, nlen-0x20, &data[nlen-0x20]);
fwrite(data, 1, nlen, g);
fclose(g);
}
void decode_dir(struct tf_packet *p)
{
__u16 count =
(get_u16(&p->length) - PACKET_HEAD_SIZE) / sizeof(struct typefile);
struct typefile *entries = (struct typefile *) p->data;
int i;
time_t timestamp;
if (xml) {
printf("<?xml version=\"1.0\" encoding=\"ISO-8859-15\"?>\r\n\r\n");
printf("<contents>\n");
}
for(i = 0; (i < count); i++)
{
/* This makes the assumption that the timezone of the Toppy and the system
* that puppy runs on are the same. Given the limitations on the length of
* USB cables, this condition is likely to be satisfied. */
struct tm tm;
timestamp = tfdt_to_time(&entries[i].stamp);
tm = *localtime(×tamp);
if (xml) {
int ft = entries[i].filetype;
printf("<file type=\"%s\" size=\"%llu\" time=\"%04d-%02d-%02d %d:%02d:%02d\" name=\"%W\"/>\n",
ft == 1 ? "dir" :
ft == 2 ? "file" :
"unknown",
get_u64(&entries[i].size),
tm.tm_year + 1900,
tm.tm_mon + 1,
tm.tm_mday,
tm.tm_hour,
tm.tm_min,
tm.tm_sec,
entries[i].name);
} else {
char type;
switch (entries[i].filetype)
{
case 1:
type = 'd';
break;
case 2:
type = 'f';
break;
default:
type = '?';
}
printf("%c %20llu %24.24s %s\n", type, get_u64(&entries[i].size),
ctime(×tamp), entries[i].name);
}
}
if (xml) {
printf("</contents>\n");
}
}
static void
decode_and_get_info(Camera *camera, const char *folder, struct tf_packet *p, const char *fn,
CameraFileInfo *info, GPContext *context)
{
unsigned short count = (get_u16(&p->length) - PACKET_HEAD_SIZE) / sizeof(struct typefile);
struct typefile *entries = (struct typefile *) p->data;
int i;
char *name;
for(i = 0; i < count; i++) {
switch (entries[i].filetype) {
case 1: break;/*dir*/
case 2: /* file */
name = _convert_and_logname (camera, (char*)entries[i].name);
if (!strcmp (name, fn)) { /* the wanted current one */
memset (info, 0, sizeof (*info));
info->file.fields = GP_FILE_INFO_SIZE|GP_FILE_INFO_MTIME;
if (strstr (name, ".rec")) {
info->file.fields |= GP_FILE_INFO_TYPE;
strcpy (info->file.type, GP_MIME_MPEG);
}
info->file.size = get_u64(&entries[i].size);
info->file.mtime = tfdt_to_time(&entries[i].stamp);
} else { /* cache the others to avoid further turnarounds */
CameraFileInfo xinfo;
memset (&xinfo, 0, sizeof (xinfo));
xinfo.file.fields = GP_FILE_INFO_TYPE|GP_FILE_INFO_SIZE|GP_FILE_INFO_MTIME;
strcpy (xinfo.file.type, GP_MIME_MPEG);
xinfo.file.size = get_u64(&entries[i].size);
xinfo.file.mtime = tfdt_to_time(&entries[i].stamp);
gp_filesystem_append (camera->fs, folder, name, context); /* FIXME: might fail if exist? */
gp_filesystem_set_info_noop (camera->fs, folder, name, xinfo, context);
}
break;
default:
break;
}
#if 0
/* This makes the assumption that the timezone of the Toppy and the system
* that puppy runs on are the same. Given the limitations on the length of
* USB cables, this condition is likely to be satisfied. */
timestamp = tfdt_to_time(&entries[i].stamp);
printf("%c %20llu %24.24s %s\n", type, get_u64(&entries[i].size),
ctime(×tamp), entries[i].name);
#endif
}
}
void ipoque_search_mysql_tcp(struct ipoque_detection_module_struct *ipoque_struct)
{
struct ipoque_packet_struct *packet = &ipoque_struct->packet;
struct ipoque_flow_struct *flow = ipoque_struct->flow;
// struct ipoque_id_struct *src=ipoque_struct->src;
// struct ipoque_id_struct *dst=ipoque_struct->dst;
if (packet->payload_packet_len > 37 //min length
&& get_u16(packet->payload, 0) == packet->payload_packet_len - 4 //first 3 bytes are length
&& get_u8(packet->payload, 2) == 0x00 //3rd byte of packet length
&& get_u8(packet->payload, 3) == 0x00 //packet sequence number is 0 for startup packet
&& get_u8(packet->payload, 5) > 0x30 //server version > 0
&& get_u8(packet->payload, 5) < 0x37 //server version < 7
&& get_u8(packet->payload, 6) == 0x2e //dot
) {
u32 a;
for (a = 7; a + 31 < packet->payload_packet_len; a++) {
if (packet->payload[a] == 0x00) {
if (get_u8(packet->payload, a + 13) == 0x00 //filler byte
&& get_u64(packet->payload, a + 19) == 0x0ULL //13 more
&& get_u32(packet->payload, a + 27) == 0x0 //filler bytes
&& get_u8(packet->payload, a + 31) == 0x0) {
IPQ_LOG(IPOQUE_PROTOCOL_MYSQL, ipoque_struct, IPQ_LOG_DEBUG, "MySQL detected.\n");
ipoque_int_mysql_add_connection(ipoque_struct);
return;
}
break;
}
}
}
IPOQUE_ADD_PROTOCOL_TO_BITMASK(flow->excluded_protocol_bitmask, IPOQUE_PROTOCOL_MYSQL);
}
int xfrm_lifetime_cfg_parse(struct xfrm_lifetime_cfg *lft,
int *argcp, char ***argvp)
{
int argc = *argcp;
char **argv = *argvp;
int ret;
if (strcmp(*argv, "time-soft") == 0) {
NEXT_ARG();
ret = get_u64(&lft->soft_add_expires_seconds, *argv, 0);
if (ret)
invarg("\"time-soft\" value is invalid", *argv);
} else if (strcmp(*argv, "time-hard") == 0) {
NEXT_ARG();
ret = get_u64(&lft->hard_add_expires_seconds, *argv, 0);
if (ret)
invarg("\"time-hard\" value is invalid", *argv);
} else if (strcmp(*argv, "time-use-soft") == 0) {
NEXT_ARG();
ret = get_u64(&lft->soft_use_expires_seconds, *argv, 0);
if (ret)
invarg("\"time-use-soft\" value is invalid", *argv);
} else if (strcmp(*argv, "time-use-hard") == 0) {
NEXT_ARG();
ret = get_u64(&lft->hard_use_expires_seconds, *argv, 0);
if (ret)
invarg("\"time-use-hard\" value is invalid", *argv);
} else if (strcmp(*argv, "byte-soft") == 0) {
NEXT_ARG();
ret = get_u64(&lft->soft_byte_limit, *argv, 0);
if (ret)
invarg("\"byte-soft\" value is invalid", *argv);
} else if (strcmp(*argv, "byte-hard") == 0) {
NEXT_ARG();
ret = get_u64(&lft->hard_byte_limit, *argv, 0);
if (ret)
invarg("\"byte-hard\" value is invalid", *argv);
} else if (strcmp(*argv, "packet-soft") == 0) {
NEXT_ARG();
ret = get_u64(&lft->soft_packet_limit, *argv, 0);
if (ret)
invarg("\"packet-soft\" value is invalid", *argv);
} else if (strcmp(*argv, "packet-hard") == 0) {
NEXT_ARG();
ret = get_u64(&lft->hard_packet_limit, *argv, 0);
if (ret)
invarg("\"packet-hard\" value is invalid", *argv);
} else
invarg("\"LIMIT\" is invalid", *argv);
*argcp = argc;
*argvp = argv;
return 0;
}
int
buffer_get_int64_ret(u_int64_t *ret, Buffer *buffer)
{
u_char buf[8];
if (buffer_get_ret(buffer, (char *) buf, 8) == -1)
return (-1);
*ret = get_u64(buf);
return (0);
}
int get_be64(__be64 *val, const char *arg, int base)
{
__u64 v;
int ret = get_u64(&v, arg, base);
if (!ret)
*val = htonll(v);
return ret;
}
/* Compare per-file extra data;
Update compressed_size if it is not NULL, otherwise assume compressed_size
is not present in the zip64 header. */
static enum result
cmp_file_extra(const unsigned char **p1, const unsigned char **p2, off_t *p3,
size_t extra_len, int *is_zip64,
unsigned long long *compressed_size)
{
const unsigned char *data1, *data2;
off_t size_left;
data1 = *p1;
data2 = *p2;
size_left = *p3;
while (extra_len >= sizeof(struct extra_header)) {
struct extra_header eh;
size_t len;
memcpy(&eh, data1, sizeof(eh));
COMPARE_AND_ADVANCE(sizeof(eh));
len = get_u16(eh.data_size);
if (extra_len < sizeof(eh) + len)
return RES_UNKNOWN;
extra_len -= sizeof(eh) + len;
if (memcmp(eh.id, eh_id_zip64, sizeof(eh_id_zip64)) == 0) {
*is_zip64 = 1;
if (compressed_size != NULL)
*compressed_size = get_u64(data1 + 8);
COMPARE_AND_ADVANCE(len);
} else if (memcmp(eh.id, eh_id_ext_timestamp,
sizeof(eh_id_ext_timestamp)) == 0) {
if (len < 1)
return RES_UNKNOWN;
COMPARE_AND_ADVANCE(1); /* Time presence flags */
ADVANCE(len - 1); /* mtime, atime, ctime - if present */
} else
COMPARE_AND_ADVANCE(len);
}
if (extra_len != 0)
return RES_UNKNOWN;
*p1 = data1;
*p2 = data2;
*p3 = size_left;
return RES_SAME;
}
/* Clear per-file extra data;
Update compressed_size if it is not NULL, otherwise assume compressed_size
is not present in the zip64 header. */
static int
clear_file_extra(unsigned char **p1, off_t *p2, size_t extra_len, int *is_zip64,
unsigned long long *compressed_size)
{
unsigned char *data;
off_t size_left;
data = *p1;
size_left = *p2;
while (extra_len >= sizeof(struct extra_header)) {
struct extra_header eh;
size_t len;
memcpy(&eh, data, sizeof(eh));
ADVANCE(sizeof(eh));
len = get_u16(eh.data_size);
if (extra_len < sizeof(eh) + len)
return -1;
extra_len -= sizeof(eh) + len;
if (memcmp(eh.id, eh_id_zip64, sizeof(eh_id_zip64)) == 0) {
*is_zip64 = 1;
if (compressed_size != NULL)
*compressed_size = get_u64(data + 8);
ADVANCE(len);
} else if (memcmp(eh.id, eh_id_ext_timestamp,
sizeof(eh_id_ext_timestamp)) == 0) {
if (len < 1)
return -1;
ADVANCE(1); /* Time presence flags */
memset(data, 0, len - 1); /* mtime, atime, ctime - if present */
ADVANCE(len - 1);
} else
ADVANCE(len);
}
if (extra_len != 0)
return -1;
*p1 = data;
*p2 = size_left;
return 0;
}
static void cmd_data_b3(int level, uint8_t subcmd, struct frame *frm)
{
uint32_t data;
uint16_t length, handle, flags, info;
cmd_common(level, 0x00, frm);
if (subcmd == 0x81 || subcmd == 0x83) {
handle = CAPI_U16(frm);
p_indent(level, frm);
printf("Data handle: 0x%04x\n", handle);
if (subcmd == 0x81) {
info = CAPI_U16(frm);
p_indent(level, frm);
printf("Info: 0x%04x (%s)\n", info, info2str(info));
}
} else {
data = CAPI_U32(frm);
length = CAPI_U16(frm);
p_indent(level, frm);
printf("Data length: 0x%04x (%d bytes)\n", length, length);
handle = CAPI_U16(frm);
p_indent(level, frm);
printf("Data handle: 0x%04x\n", handle);
flags = CAPI_U16(frm);
p_indent(level, frm);
printf("Flags: 0x%04x\n", flags);
if (data == 0)
(void) get_u64(frm);
raw_dump(level, frm);
}
}
static void
decode_dir(Camera *camera, struct tf_packet *p, int listdirs, CameraList *list)
{
unsigned short count = (get_u16(&p->length) - PACKET_HEAD_SIZE) / sizeof(struct typefile);
struct typefile *entries = (struct typefile *) p->data;
int i;
char *name;
for(i = 0; i < count; i++) {
switch (entries[i].filetype) {
case 1:
if (listdirs) {
if (!strcmp ((char*)entries[i].name, ".."))
continue;
gp_list_append (list, (char*)entries[i].name, NULL);
}
break;
case 2:
if (!listdirs) {
name = _convert_and_logname (camera, (char*)entries[i].name);
gp_list_append (list, name, NULL);
}
break;
default:
break;
}
#if 0
/* This makes the assumption that the timezone of the Toppy and the system
* that puppy runs on are the same. Given the limitations on the length of
* USB cables, this condition is likely to be satisfied. */
timestamp = tfdt_to_time(&entries[i].stamp);
printf("%c %20llu %24.24s %s\n", type, get_u64(&entries[i].size),
ctime(×tamp), entries[i].name);
#endif
}
}
static void avrcp_get_element_attributes_dump(int level, struct frame *frm,
uint8_t ctype, uint16_t len,
uint8_t pt)
{
uint64_t id;
uint8_t num;
p_indent(level, frm);
if (ctype > AVC_CTYPE_GENERAL_INQUIRY)
goto response;
if (len < 9) {
printf("PDU Malformed\n");
raw_dump(level, frm);
return;
}
id = get_u64(frm);
printf("Identifier: 0x%jx (%s)\n", id, id ? "Reserved" : "PLAYING");
p_indent(level, frm);
num = get_u8(frm);
printf("AttributeCount: 0x%02x\n", num);
for (; num > 0; num--) {
uint32_t attr;
p_indent(level, frm);
attr = get_u32(frm);
printf("Attribute: 0x%08x (%s)\n", attr, mediattr2str(attr));
}
return;
response:
if (pt == AVRCP_PACKET_TYPE_SINGLE || pt == AVRCP_PACKET_TYPE_START) {
if (len < 1) {
printf("PDU Malformed\n");
raw_dump(level, frm);
return;
}
num = get_u8(frm);
avrcp_continuing.num = num;
printf("AttributeCount: 0x%02x\n", num);
len--;
} else {
num = avrcp_continuing.num;
if (avrcp_continuing.size > 0) {
uint16_t size;
if (avrcp_continuing.size > len) {
size = len;
avrcp_continuing.size -= len;
} else {
size = avrcp_continuing.size;
avrcp_continuing.size = 0;
}
printf("ContinuingAttributeValue: ");
for (; size > 0; size--) {
uint8_t c = get_u8(frm);
printf("%1c", isprint(c) ? c : '.');
}
printf("\n");
len -= size;
}
}
while (num > 0 && len > 0) {
uint32_t attr;
uint16_t charset, attrlen;
p_indent(level, frm);
attr = get_u32(frm);
printf("Attribute: 0x%08x (%s)\n", attr, mediattr2str(attr));
p_indent(level, frm);
charset = get_u16(frm);
printf("CharsetID: 0x%04x (%s)\n", charset,
charset2str(charset));
p_indent(level, frm);
attrlen = get_u16(frm);
printf("AttributeValueLength: 0x%04x\n", attrlen);
len -= sizeof(attr) + sizeof(charset) + sizeof(attrlen);
num--;
p_indent(level, frm);
printf("AttributeValue: ");
for (; attrlen > 0 && len > 0; attrlen--, len--) {
uint8_t c = get_u8(frm);
printf("%1c", isprint(c) ? c : '.');
}
printf("\n");
if (attrlen > 0)
avrcp_continuing.size = attrlen;
}
avrcp_continuing.num = num;
}
static int
buffer_read_file(buffer_t *buffer, FILE *f, zip_error_t *error)
{
zip_uint8_t b[20];
zip_uint64_t i;
if (fread(b, 20, 1, f) != 1) {
zip_error_set(error, ZIP_ER_READ, errno);
return -1;
}
if (memcmp(b, MARK_BEGIN, 4) != 0) {
zip_error_set(error, ZIP_ER_READ, EFTYPE);
return -1;
}
buffer->fragment_size = get_u64(b+4);
buffer->size = get_u64(b+12);
if (buffer->size + buffer->fragment_size < buffer->size) {
zip_error_set(error, ZIP_ER_MEMORY, 0);
return -1;
}
buffer->nfragments = (buffer->size + buffer->fragment_size - 1) / buffer->fragment_size;
if ((buffer->nfragments > SIZE_MAX/sizeof(buffer->fragment[0]))
|| ((buffer->fragment = (zip_uint8_t **)malloc(sizeof(buffer->fragment[0]) * buffer->nfragments)) == NULL)) {
zip_error_set(error, ZIP_ER_MEMORY, 0);
return -1;
}
for (i = 0; i < buffer->nfragments; i++) {
buffer->fragment[i] = NULL;
}
i = 0;
while (i < buffer->nfragments) {
if (fread(b, 4, 1, f) != 1) {
zip_error_set(error, ZIP_ER_READ, errno);
return -1;
}
if (memcmp(b, MARK_DATA, 4) == 0) {
if (buffer->fragment_size > SIZE_MAX) {
zip_error_set(error, ZIP_ER_MEMORY, 0);
return -1;
}
if ((buffer->fragment[i] = (zip_uint8_t *)malloc(buffer->fragment_size)) == NULL) {
zip_error_set(error, ZIP_ER_MEMORY, 0);
return -1;
}
if (fread(buffer->fragment[i], buffer->fragment_size, 1, f) != 1) {
zip_error_set(error, ZIP_ER_READ, errno);
return -1;
}
i++;
}
else if (memcmp(b, MARK_NUL, 4) == 0) {
if (fread(b, 8, 1, f) != 1) {
zip_error_set(error, ZIP_ER_READ, errno);
return -1;
}
i += get_u64(b);
}
else {
zip_error_set(error, ZIP_ER_READ, EFTYPE);
return -1;
}
}
return 0;
}
int do_hdd_file_get(int fd, char *srcPath, char *dstPath)
{
int result = -EPROTO;
time_t startTime = time(NULL);
enum
{
START,
DATA,
ABORT
} state;
int dst = -1;
int r;
int update = 0;
__u64 byteCount = 0;
struct utimbuf mod_utime_buf = { 0, 0 };
dst = open64(dstPath, O_WRONLY | O_CREAT | O_TRUNC,
S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
if(dst < 0)
{
fprintf(stderr, "ERROR: Can not open destination file: %s\n",
strerror(errno));
return errno;
}
r = send_cmd_hdd_file_send(fd, GET, srcPath);
if(r < 0)
{
goto out;
}
state = START;
while(0 < (r = get_tf_packet(fd, &reply)))
{
update = (update + 1) % 16;
switch (get_u32(&reply.cmd))
{
case DATA_HDD_FILE_START:
if(state == START)
{
struct typefile *tf = (struct typefile *) reply.data;
byteCount = get_u64(&tf->size);
mod_utime_buf.actime = mod_utime_buf.modtime =
tfdt_to_time(&tf->stamp);
send_success(fd);
state = DATA;
}
else
{
fprintf(stderr,
"ERROR: Unexpected DATA_HDD_FILE_START packet in state %d\n",
state);
send_cancel(fd);
state = ABORT;
}
break;
case DATA_HDD_FILE_DATA:
if(state == DATA)
{
__u64 offset = get_u64(reply.data);
__u16 dataLen =
get_u16(&reply.length) - (PACKET_HEAD_SIZE + 8);
ssize_t w;
if(!update && !quiet)
{
progressStats(byteCount, offset + dataLen, startTime);
}
if(r < get_u16(&reply.length))
{
fprintf(stderr,
"ERROR: Short packet %d instead of %d\n", r,
get_u16(&reply.length));
/* TODO: Fetch the rest of the packet */
}
w = write(dst, &reply.data[8], dataLen);
if(w < dataLen)
{
/* Can't write data - abort transfer */
fprintf(stderr, "ERROR: Can not write data: %s\n",
strerror(errno));
send_cancel(fd);
state = ABORT;
}
}
else
{
fprintf(stderr,
"ERROR: Unexpected DATA_HDD_FILE_DATA packet in state %d\n",
state);
send_cancel(fd);
state = ABORT;
}
break;
case DATA_HDD_FILE_END:
send_success(fd);
result = 0;
goto out;
break;
case FAIL:
fprintf(stderr, "ERROR: Device reports %s\n",
decode_error(&reply));
send_cancel(fd);
state = ABORT;
break;
case SUCCESS:
goto out;
break;
default:
fprintf(stderr, "ERROR: Unhandled packet (cmd 0x%x)\n",
get_u32(&reply.cmd));
}
}
utime(dstPath, &mod_utime_buf);
finalStats(byteCount, startTime);
out:
close(dst);
return result;
}
void test_section_header64(int index)
{
memcpy(&Elf_Section_Header64, (elf + get_u64(&Elf_Header64.e_shoff) + (index * sizeof(Elf_Section_Header64))), sizeof(Elf_Section_Header64));
printf("\nTesting Section Header %d\n", index);
printf("----------------------\n");
///Section Name
printf("Section Name: %d\n", get_u32(&Elf_Section_Header64.sh_name));
///Section Type
switch(get_u32(&Elf_Section_Header64.sh_type))
{
case SHT_NULL:
printf("Section Type: Inactive\n");
break;
case SHT_PROGBITS:
printf("Section Type: Program Defined Information\n");
break;
case SHT_SYMTAB:
printf("Section Type: Symbol Table Section\n");
break;
case SHT_STRTAB:
printf("Section Type: String Table Section\n");
break;
case SHT_RELA:
printf("Section Type: Relocation Section with Appends\n");
break;
case SHT_HASH:
printf("Section Type: Symbol Hash Table Section\n");
break;
case SHT_DYNAMIC:
printf("Section Type: Dynamic Section\n");
break;
case SHT_NOTE:
printf("Section Type: Note Section\n");
break;
case SHT_NOBITS:
printf("Section Type: No Space Section\n");
break;
case SHT_REL:
printf("Section Type: Relation Section Without Appends\n");
break;
case SHT_SHLIB:
printf("Section Type: Reserved\n");
break;
case SHT_DYNSYM:
printf("Section Type: Dynamic Symbol Table Section\n");
break;
case SHT_LOPROC:
printf("Section Type: Reserved Range for Processor\n");
break;
case SHT_HIPROC:
printf("Section Type: Specific Section Header Types\n");
break;
case SHT_LOUSER:
printf("Section Type: Reserved Range for Application\n");
break;
case SHT_HIUSER:
printf("Section Type: Specifc Indexes\n");
break;
default:
printf("Incorrect Section Type\n");
}
///Section Flags
switch(get_u64(&Elf_Section_Header64.sh_flags))
{
case 0:
printf("No Section Flags Set\n");
break;
case SHF_WRITE:
printf("Section Flags: Contains Writable Data\n");
break;
case SHF_ALLOC:
printf("Section Flags: Occupies Memory\n");
break;
case SHF_EXECINSTR:
printf("Section Flags: Contains Instructions\n");
break;
case SHF_MASKPROC:
printf("Section Flags: Reserved for Processor-Specific things\n");
break;
case (SHF_WRITE + SHF_ALLOC):
printf("Section Flags: Contains Writable Data and Occupies Memory\n");
break;
case (SHF_WRITE + SHF_EXECINSTR):
printf("Section Flags: Contains Writable Data and Instructions\n");
break;
case (SHF_WRITE + SHF_MASKPROC):
printf("Section Flags: Contains Writable Data and is Reserved for Processor-Specific things\n");
break;
case (SHF_ALLOC + SHF_EXECINSTR):
printf("Section Flags: Occupies Memory and Contains Instructions\n");
break;
case (SHF_ALLOC + SHF_MASKPROC):
printf("Section Flags: Occupies Memory and is Reserved for Processor-Specific things\n");
break;
case (SHF_EXECINSTR + SHF_MASKPROC):
printf("Section Flags: Contains Instructions and is Reserved for Processor-Specific things\n");
break;
case (SHF_WRITE + SHF_ALLOC + SHF_EXECINSTR):
printf("Section Flags: Contains Writable Data, Occupies Memory, and Contains Instructions\n");
break;
case (SHF_WRITE + SHF_ALLOC + SHF_MASKPROC):
printf("Section Flags: Contains Writable Data, Occupies Memory, and is Reserved for Processor-Specific things\n");
break;
case (SHF_ALLOC + SHF_EXECINSTR + SHF_MASKPROC):
printf("Section Flags: Occupies Memory, Contains Instructions, and is Reserved for Processor-Specific things\n");
break;
case (SHF_WRITE + SHF_ALLOC + SHF_EXECINSTR + SHF_MASKPROC):
printf("Section Flags: Contains Writable Data, Occupies Memory, Contains Instructions, and is Reserved for Processor-Specific things\n");
break;
default:
printf("Section Flags are Uknown\n");
}
///Address in Memory
printf("Address in Memory: %d\n", get_u64(&Elf_Section_Header64.sh_addr));
///Offset in File
printf("Offset in File: %d\n", get_u64(&Elf_Section_Header64.sh_offset));
///Size in bytes
printf("Size in Bytes: %d\n", get_u64(&Elf_Section_Header64.sh_size));
///Index of a related section
printf("Index of Related Section: %d\n", get_u32(&Elf_Section_Header64.sh_link));
///Info dependent on Section Type
printf("Info: %d\n", get_u32(&Elf_Section_Header64.sh_info));
///Alignment in bytes
printf("Alignment in Bytes: %d\n", get_u64(&Elf_Section_Header64.sh_addralign));
///Size of Each Entry in Section
printf("Size of Each Entry: %d\n", get_u64(&Elf_Section_Header64.sh_entsize));
printf("\n\n");
}
static int ipntable_modify(int cmd, int flags, int argc, char **argv)
{
struct {
struct nlmsghdr n;
struct ndtmsg ndtm;
char buf[1024];
} req;
char *namep = NULL;
char *threshsp = NULL;
char *gc_intp = NULL;
char parms_buf[1024];
struct rtattr *parms_rta = (struct rtattr *)parms_buf;
int parms_change = 0;
memset(&req, 0, sizeof(req));
req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ndtmsg));
req.n.nlmsg_flags = NLM_F_REQUEST|flags;
req.n.nlmsg_type = cmd;
req.ndtm.ndtm_family = preferred_family;
req.ndtm.ndtm_pad1 = 0;
req.ndtm.ndtm_pad2 = 0;
memset(&parms_buf, 0, sizeof(parms_buf));
parms_rta->rta_type = NDTA_PARMS;
parms_rta->rta_len = RTA_LENGTH(0);
while (argc > 0) {
if (strcmp(*argv, "name") == 0) {
int len;
NEXT_ARG();
if (namep)
duparg("NAME", *argv);
namep = *argv;
len = strlen(namep) + 1;
addattr_l(&req.n, sizeof(req), NDTA_NAME, namep, len);
} else if (strcmp(*argv, "thresh1") == 0) {
__u32 thresh1;
NEXT_ARG();
threshsp = *argv;
if (get_u32(&thresh1, *argv, 0))
invarg("\"thresh1\" value is invalid", *argv);
addattr32(&req.n, sizeof(req), NDTA_THRESH1, thresh1);
} else if (strcmp(*argv, "thresh2") == 0) {
__u32 thresh2;
NEXT_ARG();
threshsp = *argv;
if (get_u32(&thresh2, *argv, 0))
invarg("\"thresh2\" value is invalid", *argv);
addattr32(&req.n, sizeof(req), NDTA_THRESH2, thresh2);
} else if (strcmp(*argv, "thresh3") == 0) {
__u32 thresh3;
NEXT_ARG();
threshsp = *argv;
if (get_u32(&thresh3, *argv, 0))
invarg("\"thresh3\" value is invalid", *argv);
addattr32(&req.n, sizeof(req), NDTA_THRESH3, thresh3);
} else if (strcmp(*argv, "gc_int") == 0) {
__u64 gc_int;
NEXT_ARG();
gc_intp = *argv;
if (get_u64(&gc_int, *argv, 0))
invarg("\"gc_int\" value is invalid", *argv);
addattr_l(&req.n, sizeof(req), NDTA_GC_INTERVAL,
&gc_int, sizeof(gc_int));
} else if (strcmp(*argv, "dev") == 0) {
__u32 ifindex;
NEXT_ARG();
ifindex = ll_name_to_index(*argv);
if (ifindex == 0) {
fprintf(stderr, "Cannot find device \"%s\"\n", *argv);
return -1;
}
rta_addattr32(parms_rta, sizeof(parms_buf),
NDTPA_IFINDEX, ifindex);
} else if (strcmp(*argv, "base_reachable") == 0) {
__u64 breachable;
NEXT_ARG();
if (get_u64(&breachable, *argv, 0))
invarg("\"base_reachable\" value is invalid", *argv);
rta_addattr_l(parms_rta, sizeof(parms_buf),
NDTPA_BASE_REACHABLE_TIME,
&breachable, sizeof(breachable));
parms_change = 1;
} else if (strcmp(*argv, "retrans") == 0) {
__u64 retrans;
NEXT_ARG();
if (get_u64(&retrans, *argv, 0))
invarg("\"retrans\" value is invalid", *argv);
rta_addattr_l(parms_rta, sizeof(parms_buf),
NDTPA_RETRANS_TIME,
&retrans, sizeof(retrans));
parms_change = 1;
} else if (strcmp(*argv, "gc_stale") == 0) {
__u64 gc_stale;
NEXT_ARG();
if (get_u64(&gc_stale, *argv, 0))
invarg("\"gc_stale\" value is invalid", *argv);
rta_addattr_l(parms_rta, sizeof(parms_buf),
NDTPA_GC_STALETIME,
&gc_stale, sizeof(gc_stale));
parms_change = 1;
} else if (strcmp(*argv, "delay_probe") == 0) {
__u64 delay_probe;
NEXT_ARG();
if (get_u64(&delay_probe, *argv, 0))
invarg("\"delay_probe\" value is invalid", *argv);
rta_addattr_l(parms_rta, sizeof(parms_buf),
NDTPA_DELAY_PROBE_TIME,
&delay_probe, sizeof(delay_probe));
parms_change = 1;
} else if (strcmp(*argv, "queue") == 0) {
__u32 queue;
NEXT_ARG();
if (get_u32(&queue, *argv, 0))
invarg("\"queue\" value is invalid", *argv);
if (!parms_rta)
parms_rta = (struct rtattr *)&parms_buf;
rta_addattr32(parms_rta, sizeof(parms_buf),
NDTPA_QUEUE_LEN, queue);
parms_change = 1;
} else if (strcmp(*argv, "app_probes") == 0) {
__u32 aprobe;
NEXT_ARG();
if (get_u32(&aprobe, *argv, 0))
invarg("\"app_probes\" value is invalid", *argv);
rta_addattr32(parms_rta, sizeof(parms_buf),
NDTPA_APP_PROBES, aprobe);
parms_change = 1;
} else if (strcmp(*argv, "ucast_probes") == 0) {
__u32 uprobe;
NEXT_ARG();
if (get_u32(&uprobe, *argv, 0))
invarg("\"ucast_probes\" value is invalid", *argv);
rta_addattr32(parms_rta, sizeof(parms_buf),
NDTPA_UCAST_PROBES, uprobe);
parms_change = 1;
} else if (strcmp(*argv, "mcast_probes") == 0) {
__u32 mprobe;
NEXT_ARG();
if (get_u32(&mprobe, *argv, 0))
invarg("\"mcast_probes\" value is invalid", *argv);
rta_addattr32(parms_rta, sizeof(parms_buf),
NDTPA_MCAST_PROBES, mprobe);
parms_change = 1;
} else if (strcmp(*argv, "anycast_delay") == 0) {
__u64 anycast_delay;
NEXT_ARG();
if (get_u64(&anycast_delay, *argv, 0))
invarg("\"anycast_delay\" value is invalid", *argv);
rta_addattr_l(parms_rta, sizeof(parms_buf),
NDTPA_ANYCAST_DELAY,
&anycast_delay, sizeof(anycast_delay));
parms_change = 1;
} else if (strcmp(*argv, "proxy_delay") == 0) {
__u64 proxy_delay;
NEXT_ARG();
if (get_u64(&proxy_delay, *argv, 0))
invarg("\"proxy_delay\" value is invalid", *argv);
rta_addattr_l(parms_rta, sizeof(parms_buf),
NDTPA_PROXY_DELAY,
&proxy_delay, sizeof(proxy_delay));
parms_change = 1;
} else if (strcmp(*argv, "proxy_queue") == 0) {
__u32 pqueue;
NEXT_ARG();
if (get_u32(&pqueue, *argv, 0))
invarg("\"proxy_queue\" value is invalid", *argv);
rta_addattr32(parms_rta, sizeof(parms_buf),
NDTPA_PROXY_QLEN, pqueue);
parms_change = 1;
} else if (strcmp(*argv, "locktime") == 0) {
__u64 locktime;
NEXT_ARG();
if (get_u64(&locktime, *argv, 0))
invarg("\"locktime\" value is invalid", *argv);
rta_addattr_l(parms_rta, sizeof(parms_buf),
NDTPA_LOCKTIME,
&locktime, sizeof(locktime));
parms_change = 1;
} else {
invarg("unknown", *argv);
}
argc--; argv++;
}
if (!namep)
missarg("NAME");
if (!threshsp && !gc_intp && !parms_change) {
fprintf(stderr, "Not enough information: changable attributes required.\n");
exit(-1);
}
if (parms_rta->rta_len > RTA_LENGTH(0)) {
addattr_l(&req.n, sizeof(req), NDTA_PARMS, RTA_DATA(parms_rta),
RTA_PAYLOAD(parms_rta));
}
if (rtnl_talk(&rth, &req.n, 0, 0, NULL, NULL, NULL) < 0)
exit(2);
return 0;
}
void test_header64(void)
{
// Elf64_Ehdr Elf_Header64;
memcpy(&Elf_Header64, elf, sizeof(Elf_Header64));
printf("\nTesting Elf Header\n");
printf("------------------\n");
///Test File Type
switch(get_u16(&Elf_Header64.e_type))
{
case ET_NONE:
printf("File Type: Unknown Type\n");
break;
case ET_REL:
printf("File Type: Relocatable\n");
break;
case ET_EXEC:
printf("File Type: Executable\n");
break;
case ET_DYN:
printf("File Type: Shared Object\n");
break;
case ET_CORE:
printf("File Type: Core File\n");
break;
default:
printf("Incorrect File Type Set");
}
///Test Machine Architecture
switch(get_u16(&Elf_Header64.e_machine)){
case EM_NONE:
printf("Machine Architecture: Unkown\n");
break;
case EM_M32:
printf("Machine Architecture: AT&T WE32100\n");
break;
case EM_SPARC:
printf("Machine Architecture: Sun SPARC\n");
break;
case EM_386:
printf("Machine Architecture: Intel i386\n");
break;
case EM_68K:
printf("Machine Architecture: Motorola 68000\n");
break;
case EM_88K:
printf("Machine Architecture: Motorola 88000\n");
break;
case EM_486:
printf("Machine Architecture: Intel i486\n");
break;
case EM_860:
printf("Machine Architecture: Intel i860\n");
break;
case EM_MIPS:
printf("Machine Architecture: MIPS R3000 Big-Endian only\n");
break;
case EM_S370:
printf("Machine Architecture: IBM System/370\n");
break;
case EM_MIPS_RS4_BE:
printf("Machine Architecture: MIPS R4000 Big-Endian\n");
break;
case EM_PARISC:
printf("Machine Architecture: HPPA\n");
break;
case EM_SPARC32PLUS:
printf("Machine Architecture: SPARC v8plus\n");
break;
case EM_PPC:
printf("Machine Architecture: PowerPC 32-bit\n");
break;
case EM_PPC64:
printf("Machine Architecture: PowerPC 64-bit\n");
break;
case EM_ARM:
printf("Machine Architecture: ARM \n");
break;
case EM_SPARCV9:
printf("Machine Architecture: SPARC v9 64-bit\n");
break;
case EM_IA_64:
printf("Machine Architecture: Intel IA-46 Processor\n");
break;
case EM_X86_64:
printf("Machine Architecture: Advanced Micro Devices x86-64\n");
break;
default:
printf("Machine Architecture is invalid type...\n");
}
///Test Elf Format Version
///Test Elf Format Version
if(get_u32(&Elf_Header64.e_version) == EV_NONE)
printf("Elf Format Version: None\n");
else if(get_u32(&Elf_Header64.e_version) == EV_CURRENT)
printf("Elf Format Version: Current\n");
else
printf("Incorrect Elf Format Version");
///Test Entry Point
printf("Entry Point: %d\n", get_u64(&Elf_Header64.e_entry));
///Test Program Header File Offset
printf("Program Header File Offset: %d\n", get_u64(&Elf_Header64.e_phoff));
///Test Section Header File Offset
printf("Section Header File Offset: %d\n", get_u64(&Elf_Header64.e_shoff));
///Test Flags
printf("Flags: %d\n", get_u32(&Elf_Header64.e_flags));
///Test Size of Header in Bytes
printf("Size of Header: %d\n", get_u16(&Elf_Header64.e_ehsize));
///Test Size of Program Header Entry
printf("Size of Program Header Entry: %d\n", get_u16(&Elf_Header64.e_phentsize));
///Test Number of Program Header Entries
printf("Program Header Entries: %d\n",get_u16(&Elf_Header64.e_phnum));
///Test Size of Section Header Entry
printf("Size of Section Header Entry: %d\n", get_u16(&Elf_Header64.e_shentsize));
///Test Number of Section Header Entries
printf("Number of Section Header Entries: %d\n", get_u16(&Elf_Header64.e_shnum));
///Test Section Name Strings Section
printf("Section Name Strings Section: %d\n", get_u16(&Elf_Header64.e_shstrndx));
printf("\n\n");
}
void test_program_header64(int index)
{
memcpy(&Elf_Program_Header64, (elf + get_u64(&Elf_Header64.e_phoff) + (index * sizeof(Elf_Program_Header64))), sizeof(Elf_Program_Header64));
printf("\nTesting Program Header %d\n", index);
printf("----------------------\n");
/// Entry Type
switch(get_u32(&Elf_Program_Header64.p_type))
{
case PT_NULL:
printf("Entry Type: Unsused\n");
break;
case PT_LOAD:
printf("Entry Type: Loadable Segment\n");
break;
case PT_DYNAMIC:
printf("Entry Type: Dynamic Linking Information Segment\n");
break;
case PT_INTERP:
printf("Entry Type: Pathname of Interpreter\n");
break;
case PT_NOTE:
printf("Entry Type: Auxiliary Information\n");
break;
case PT_SHLIB:
printf("Entry Type: Reserved (not used)\n");
break;
case PT_PHDR:
printf("Entry Type: Location of Program Header Itself\n");
break;
default:
printf("Entry Type is Unknown\n");
}
/// Access permission flags.
switch(get_u32(&Elf_Program_Header64.p_flags))
{
case PF_X:
printf("Access permission: Executable\n");
break;
case PF_W:
printf("Access permission: Writable\n");
break;
case PF_R:
printf("Access permission: Readable\n");
break;
case (PF_X + PF_W):
printf("Access permission: Executable and Writable\n");
break;
case (PF_X + PF_R):
printf("Access permission: Executable and Readable\n");
break;
case (PF_W + PF_R):
printf("Access permission: Writable and Readable\n");
break;
case (PF_X + PF_W + PF_R):
printf("Access permission: Executabl, Writable, and Readable\n");
default:
printf("Access Permission is Unknown %d\n", get_u32(&Elf_Program_Header64.p_flags));
}
/// File Offset of Contents
printf("File Offset of Contents: %d\n", get_u64(&Elf_Program_Header64.p_offset));
/// Virtual Address in memory image
printf("Virtual Address: %d\n", get_u64(&Elf_Program_Header64.p_vaddr));
/// Physical address (not used)
printf("Physical address: %d\n", get_u64(&Elf_Program_Header64.p_paddr));
/// Size of contents in file
printf("Size of contents in file: %d\n", get_u64(&Elf_Program_Header64.p_filesz));
/// Size of contents in memory
printf("Size of contents in memory: %d\n", get_u64(&Elf_Program_Header64.p_memsz));
/// Alignment in memory and file
printf("Alignment in memory and file: %d\n", get_u64(&Elf_Program_Header64.p_align));
printf("\n\n");
}
static int ipntable_modify(int cmd, int flags, int argc, char **argv)
{
struct {
struct nlmsghdr n;
struct ndtmsg ndtm;
char buf[1024];
} req = {
.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ndtmsg)),
.n.nlmsg_flags = NLM_F_REQUEST | flags,
.n.nlmsg_type = cmd,
.ndtm.ndtm_family = preferred_family,
};
char *namep = NULL;
char *threshsp = NULL;
char *gc_intp = NULL;
char parms_buf[1024] = {};
struct rtattr *parms_rta = (struct rtattr *)parms_buf;
int parms_change = 0;
parms_rta->rta_type = NDTA_PARMS;
parms_rta->rta_len = RTA_LENGTH(0);
while (argc > 0) {
if (strcmp(*argv, "name") == 0) {
int len;
NEXT_ARG();
if (namep)
duparg("NAME", *argv);
namep = *argv;
len = strlen(namep) + 1;
addattr_l(&req.n, sizeof(req), NDTA_NAME, namep, len);
} else if (strcmp(*argv, "thresh1") == 0) {
__u32 thresh1;
NEXT_ARG();
threshsp = *argv;
if (get_u32(&thresh1, *argv, 0))
invarg("\"thresh1\" value is invalid", *argv);
addattr32(&req.n, sizeof(req), NDTA_THRESH1, thresh1);
} else if (strcmp(*argv, "thresh2") == 0) {
__u32 thresh2;
NEXT_ARG();
threshsp = *argv;
if (get_u32(&thresh2, *argv, 0))
invarg("\"thresh2\" value is invalid", *argv);
addattr32(&req.n, sizeof(req), NDTA_THRESH2, thresh2);
} else if (strcmp(*argv, "thresh3") == 0) {
__u32 thresh3;
NEXT_ARG();
threshsp = *argv;
if (get_u32(&thresh3, *argv, 0))
invarg("\"thresh3\" value is invalid", *argv);
addattr32(&req.n, sizeof(req), NDTA_THRESH3, thresh3);
} else if (strcmp(*argv, "gc_int") == 0) {
__u64 gc_int;
NEXT_ARG();
gc_intp = *argv;
if (get_u64(&gc_int, *argv, 0))
invarg("\"gc_int\" value is invalid", *argv);
addattr_l(&req.n, sizeof(req), NDTA_GC_INTERVAL,
&gc_int, sizeof(gc_int));
} else if (strcmp(*argv, "dev") == 0) {
__u32 ifindex;
NEXT_ARG();
ifindex = ll_name_to_index(*argv);
if (!ifindex)
return nodev(*argv);
rta_addattr32(parms_rta, sizeof(parms_buf),
NDTPA_IFINDEX, ifindex);
} else if (strcmp(*argv, "base_reachable") == 0) {
__u64 breachable;
NEXT_ARG();
if (get_u64(&breachable, *argv, 0))
invarg("\"base_reachable\" value is invalid", *argv);
rta_addattr_l(parms_rta, sizeof(parms_buf),
NDTPA_BASE_REACHABLE_TIME,
&breachable, sizeof(breachable));
parms_change = 1;
} else if (strcmp(*argv, "retrans") == 0) {
__u64 retrans;
NEXT_ARG();
if (get_u64(&retrans, *argv, 0))
invarg("\"retrans\" value is invalid", *argv);
rta_addattr_l(parms_rta, sizeof(parms_buf),
NDTPA_RETRANS_TIME,
&retrans, sizeof(retrans));
parms_change = 1;
} else if (strcmp(*argv, "gc_stale") == 0) {
__u64 gc_stale;
NEXT_ARG();
if (get_u64(&gc_stale, *argv, 0))
invarg("\"gc_stale\" value is invalid", *argv);
rta_addattr_l(parms_rta, sizeof(parms_buf),
NDTPA_GC_STALETIME,
&gc_stale, sizeof(gc_stale));
parms_change = 1;
} else if (strcmp(*argv, "delay_probe") == 0) {
__u64 delay_probe;
NEXT_ARG();
if (get_u64(&delay_probe, *argv, 0))
invarg("\"delay_probe\" value is invalid", *argv);
rta_addattr_l(parms_rta, sizeof(parms_buf),
NDTPA_DELAY_PROBE_TIME,
&delay_probe, sizeof(delay_probe));
parms_change = 1;
} else if (strcmp(*argv, "queue") == 0) {
__u32 queue;
NEXT_ARG();
if (get_u32(&queue, *argv, 0))
invarg("\"queue\" value is invalid", *argv);
rta_addattr32(parms_rta, sizeof(parms_buf),
NDTPA_QUEUE_LEN, queue);
parms_change = 1;
} else if (strcmp(*argv, "app_probes") == 0) {
__u32 aprobe;
NEXT_ARG();
if (get_u32(&aprobe, *argv, 0))
invarg("\"app_probes\" value is invalid", *argv);
rta_addattr32(parms_rta, sizeof(parms_buf),
NDTPA_APP_PROBES, aprobe);
parms_change = 1;
} else if (strcmp(*argv, "ucast_probes") == 0) {
__u32 uprobe;
NEXT_ARG();
if (get_u32(&uprobe, *argv, 0))
invarg("\"ucast_probes\" value is invalid", *argv);
rta_addattr32(parms_rta, sizeof(parms_buf),
NDTPA_UCAST_PROBES, uprobe);
parms_change = 1;
} else if (strcmp(*argv, "mcast_probes") == 0) {
__u32 mprobe;
NEXT_ARG();
if (get_u32(&mprobe, *argv, 0))
invarg("\"mcast_probes\" value is invalid", *argv);
rta_addattr32(parms_rta, sizeof(parms_buf),
NDTPA_MCAST_PROBES, mprobe);
parms_change = 1;
} else if (strcmp(*argv, "anycast_delay") == 0) {
__u64 anycast_delay;
NEXT_ARG();
if (get_u64(&anycast_delay, *argv, 0))
invarg("\"anycast_delay\" value is invalid", *argv);
rta_addattr_l(parms_rta, sizeof(parms_buf),
NDTPA_ANYCAST_DELAY,
&anycast_delay, sizeof(anycast_delay));
parms_change = 1;
} else if (strcmp(*argv, "proxy_delay") == 0) {
__u64 proxy_delay;
NEXT_ARG();
if (get_u64(&proxy_delay, *argv, 0))
invarg("\"proxy_delay\" value is invalid", *argv);
rta_addattr_l(parms_rta, sizeof(parms_buf),
NDTPA_PROXY_DELAY,
&proxy_delay, sizeof(proxy_delay));
parms_change = 1;
} else if (strcmp(*argv, "proxy_queue") == 0) {
__u32 pqueue;
NEXT_ARG();
if (get_u32(&pqueue, *argv, 0))
invarg("\"proxy_queue\" value is invalid", *argv);
rta_addattr32(parms_rta, sizeof(parms_buf),
NDTPA_PROXY_QLEN, pqueue);
parms_change = 1;
} else if (strcmp(*argv, "locktime") == 0) {
__u64 locktime;
NEXT_ARG();
if (get_u64(&locktime, *argv, 0))
invarg("\"locktime\" value is invalid", *argv);
rta_addattr_l(parms_rta, sizeof(parms_buf),
NDTPA_LOCKTIME,
&locktime, sizeof(locktime));
parms_change = 1;
} else {
invarg("unknown", *argv);
}
argc--; argv++;
}
if (!namep)
missarg("NAME");
if (!threshsp && !gc_intp && !parms_change) {
fprintf(stderr, "Not enough information: changeable attributes required.\n");
exit(-1);
}
if (parms_rta->rta_len > RTA_LENGTH(0)) {
addattr_l(&req.n, sizeof(req), NDTA_PARMS, RTA_DATA(parms_rta),
RTA_PAYLOAD(parms_rta));
}
if (rtnl_talk(&rth, &req.n, NULL) < 0)
exit(2);
return 0;
}
static const char *ntable_strtime_delta(__u32 msec)
{
static char str[32];
struct timeval now = {};
time_t t;
struct tm *tp;
if (msec == 0)
goto error;
if (gettimeofday(&now, NULL) < 0) {
perror("gettimeofday");
goto error;
}
t = now.tv_sec - (msec / 1000);
tp = localtime(&t);
if (!tp)
goto error;
strftime(str, sizeof(str), "%Y-%m-%d %T", tp);
return str;
error:
strcpy(str, "(error)");
return str;
}
static void print_ndtconfig(const struct ndt_config *ndtc)
{
print_uint(PRINT_ANY, "key_length",
" config key_len %u ", ndtc->ndtc_key_len);
print_uint(PRINT_ANY, "entry_size",
"entry_size %u ", ndtc->ndtc_entry_size);
print_uint(PRINT_ANY, "entries", "entries %u ", ndtc->ndtc_entries);
print_nl();
print_string(PRINT_ANY, "last_flush",
" last_flush %s ",
ntable_strtime_delta(ndtc->ndtc_last_flush));
print_string(PRINT_ANY, "last_rand",
"last_rand %s ",
ntable_strtime_delta(ndtc->ndtc_last_rand));
print_nl();
print_uint(PRINT_ANY, "hash_rnd",
" hash_rnd %u ", ndtc->ndtc_hash_rnd);
print_0xhex(PRINT_ANY, "hash_mask",
"hash_mask %08llx ", ndtc->ndtc_hash_mask);
print_uint(PRINT_ANY, "hash_chain_gc",
"hash_chain_gc %u ", ndtc->ndtc_hash_chain_gc);
print_uint(PRINT_ANY, "proxy_qlen",
"proxy_qlen %u ", ndtc->ndtc_proxy_qlen);
print_nl();
}
int main(int argc, char* argv[]) {
int i;
u8 ecount_buf[0x10], iv[0x10];
size_t countp;
int num;
Self_Segment* segment_ptr;
memset(zero_padding, 0, sizeof(zero_padding));
#ifdef NPDRM
if(argc < 3) {
printf("usage: %s input.elf output.self <titleid>\n", argv[0]);
printf(" warning NPDRM cares about the output file name, do not rename\n");
return -1;
}
#else
if(argc < 2) {
printf("usage: %s input.elf output.self\n", argv[0]);
return -1;
}
#endif
// init randomness
gmp_randinit_default(r_state);
gmp_randseed_ui(r_state, time(NULL));
// read elf file
read_elf_file(argv[1]);
input_elf_header = (Elf64_Ehdr*)input_elf_data;
printf("ELF header size @ %x\n", get_u16(&(input_elf_header->e_ehsize)) );
printf("%d program headers @ %llx\n", get_u16(&(input_elf_header->e_phnum)), get_u64(&(input_elf_header->e_phoff)));
printf("%d section headers @ %llx\n", get_u16(&(input_elf_header->e_shnum)), get_u64(&(input_elf_header->e_shoff)));
// loop through the segments
enumerate_segments();
printf("segments enumerated\n");
// setup self headers
Self_Shdr output_self_header; memset(&output_self_header, 0, sizeof(output_self_header));
Self_Ehdr output_extended_self_header; memset(&output_extended_self_header, 0, sizeof(output_extended_self_header));
Self_Ihdr output_self_info_header; memset(&output_self_info_header, 0, sizeof(output_self_info_header));
init_Self_Shdr(&output_self_header);
init_Self_Ehdr(&output_extended_self_header);
init_Self_Ihdr(&output_self_info_header);
set_u64(&output_self_header.s_exsize, input_elf_len);
// setup segment header
segment_certification_header segment_header; memset(&segment_header, 0, sizeof(segment_header));
set_u32(&(segment_header.version), 1);
// NPDRM
#ifdef NPDRM
Self_NPDRM npdrm; memset(&npdrm, 0, sizeof(npdrm));
init_Self_NPDRM(&npdrm, argv[3], argv[2]);
#endif
// useless bullshit
Self_SDKversion sdkversion;
Self_Cflags cflags;
memcpy(&sdkversion, sdkversion_static, sizeof(Self_SDKversion));
memcpy(&cflags, cflags_static, sizeof(Self_Cflags));
// generate metadata encryption keys
metadata_crypt_header md_header; memset(&md_header, 0, sizeof(md_header));
#ifdef NPDRM
memcpy(&md_header, npdrm_keypair_d, sizeof(md_header));
#else
mpz_t bigriv, bigerk;
mpz_init(bigriv); mpz_init(bigerk);
mpz_urandomb(bigerk, r_state, 128);
mpz_urandomb(bigriv, r_state, 128);
mpz_export(md_header.erk, &countp, 1, 0x10, 1, 0, bigerk);
mpz_export(md_header.riv, &countp, 1, 0x10, 1, 0, bigriv);
#endif
// init signing shit
mpz_t n,k,da,kinv,r,cs,z;
mpz_init(n); mpz_init(k); mpz_init(da); mpz_init(r); mpz_init(cs); mpz_init(z); mpz_init(kinv);
mpz_import(r, 0x14, 1, 1, 0, 0, KEY(R));
mpz_import(n, 0x14, 1, 1, 0, 0, KEY(n));
mpz_import(k, 0x14, 1, 1, 0, 0, KEY(K));
mpz_import(da, 0x14, 1, 1, 0, 0, KEY(Da));
mpz_invert(kinv, k, n);
segment_certification_sign all_signed; memset(&all_signed, 0, sizeof(all_signed));
mpz_export(all_signed.R, &countp, 1, 0x14, 1, 0, r);
// **** everything here is still length independent ***
build_segment_crypt_data();
set_u32(&(segment_header.crypt_len), (segment_crypt_data_len)/0x10);
set_u32(&(segment_header.unknown2), 0x30); // needed??
printf("built crypt data\n");
// start building metadata in theory, ordering is fixed now
memset(&start_file, 0, sizeof(file_ll));
running_size = 0;
// 0x000 -- Self_Shdr
add_file_section(&output_self_header, sizeof(output_self_header));
// 0x020 -- Self_Ehdr
add_file_section(&output_extended_self_header, sizeof(output_extended_self_header));
// 0x070 -- Self_Ihdr
set_u64(&(output_extended_self_header.e_ihoff), running_size);
add_file_section(&output_self_info_header, sizeof(output_self_info_header));
// 0x090 -- elf data
set_u64(&(output_extended_self_header.e_ehoff), running_size);
set_u64(&(output_extended_self_header.e_phoff), running_size+get_u64(&(input_elf_header->e_phoff)));
add_file_section(input_elf_data, get_u64(&(input_elf_header->e_phoff)) + get_u16(&(input_elf_header->e_phnum)) * sizeof(Elf64_Phdr));
add_file_section(zero_padding, (0x10-(running_size&0xF))&0xF);
// 0x*** -- all Self_PMhdr(including not in crypt)
set_u64(&(output_extended_self_header.e_pmoff), running_size);
segment_ptr = &first_segment;
while(segment_ptr != NULL) {
add_file_section(&(segment_ptr->pmhdr), sizeof(segment_ptr->pmhdr));
segment_ptr = segment_ptr->next_segment;
}
// 0x*** -- Self_SDKversion
set_u64(&(output_extended_self_header.e_svoff), running_size);
add_file_section(&sdkversion, sizeof(sdkversion));
// 0x*** -- ???
#ifdef NPDRM
add_file_section(zero_padding, 0x20);
#endif
// 0x*** -- Self_Cflags
set_u64(&(output_extended_self_header.e_cfoff), running_size);
add_file_section(&cflags, sizeof(cflags));
#ifdef NPDRM
// 0x*** -- npdrm data
add_file_section(&npdrm, sizeof(npdrm));
#endif
// 0x*** -- metadata_crypt_header
set_u32(&(output_self_header.s_esize), running_size - sizeof(output_self_header));
add_file_section(&md_header, sizeof(md_header));
// 0x*** -- segment_certification_header
add_file_section(&segment_header, sizeof(segment_header));
// 0x*** -- all segment_certification_segment incrypt
int incrypt_count = 0;
segment_ptr = &first_segment;
while(segment_ptr != NULL) {
if(segment_ptr->incrypt) {
add_file_section(&(segment_ptr->enc_segment), sizeof(segment_ptr->enc_segment));
incrypt_count++;
}
segment_ptr = segment_ptr->next_segment;
}
set_u32(&(segment_header.segment_count), incrypt_count);
// 0x*** -- segment_crypt_data
add_file_section(segment_crypt_data, segment_crypt_data_len);
// 0x*** -- nubpadding_static
add_file_section(nubpadding_static, sizeof(nubpadding_static));
// 0x*** -- segment_certification_sign
set_u64(&(segment_header.signature_offset), running_size);
add_file_section(&all_signed, sizeof(all_signed));
// 0x*** -- data must be 0x80 aligned
if((running_size%0x80) != 0) {
add_file_section(zero_padding, 0x80-(running_size%0x80));
}
// 0x*** -- data
set_u64(&(output_self_header.s_shsize), running_size);
// ...data...
segment_ptr = &first_segment;
while(segment_ptr != NULL) {
set_u64(&(segment_ptr->enc_segment.segment_offset), running_size);
set_u64(&(segment_ptr->pmhdr.pm_offset), running_size);
add_file_section(segment_ptr->data, segment_ptr->len);
add_file_section(zero_padding, segment_ptr->padding);
segment_ptr = segment_ptr->next_segment;
}
// 0x*** -- section table
#ifndef SPRX
set_u64(&(output_extended_self_header.e_shoff), running_size);
add_file_section(input_elf_data+get_u64(&(input_elf_header->e_shoff)), get_u16(&(input_elf_header->e_shnum)) * sizeof(Elf64_Shdr));
#endif
// ***DONE***
printf("file built\n");
// write self file in memory <-- useful comment
write_self_file_in_memory();
printf("self written in memory\n");
// sign shit
u8 digest[0x14];
SHA1(output_self_data, get_u64(&(segment_header.signature_offset)), digest);
mpz_import(z, 0x14, 1, 1, 0, 0, digest);
mpz_mul(cs, r, da); mpz_mod(cs, cs, n);
mpz_add(cs, cs, z); mpz_mod(cs, cs, n);
mpz_mul(cs, cs, kinv); mpz_mod(cs, cs, n);
//mpz_export(all_signed.S, &countp, 1, 0x14, 1, 0, cs);
mpz_export(&output_self_data[get_u64(&output_self_data[get_u32(output_self_data+0xC)+0x60])+0x16], &countp, 1, 0x14, 1, 0, cs);
// write the output self test
FILE *test_self_file = fopen("test_out", "wb");
fwrite(output_self_data, 1, running_size, test_self_file);
fclose(test_self_file);
// encrypt metadata
int metadata_offset = get_u32(&(output_self_header.s_esize)) + sizeof(Self_Shdr);
#ifndef NO_CRYPT
memset(ecount_buf, 0, 16); num=0;
AES_set_encrypt_key(&output_self_data[metadata_offset], 128, &aes_key);
memcpy(iv, &output_self_data[metadata_offset+0x20], 16);
AES_ctr128_encrypt(&output_self_data[0x40+metadata_offset], &output_self_data[0x40+metadata_offset], get_u64(&(output_self_header.s_shsize))-metadata_offset-0x40, &aes_key, iv, ecount_buf, &num);
printf("encrypted metadata\n");
#ifdef NPDRM
memcpy(&output_self_data[metadata_offset], npdrm_keypair_e, sizeof(md_header));
#else
AES_set_encrypt_key(KEY(erk), 256, &aes_key);
memcpy(iv, KEY(riv), 16);
AES_cbc_encrypt(&output_self_data[metadata_offset], &output_self_data[metadata_offset], 0x40, &aes_key, iv, AES_ENCRYPT);
printf("encrypted keys\n");
#endif
#else
printf("NO_CRYPT is enabled...self is broken\n");
#endif
// write the output self
FILE *output_self_file = fopen(argv[2], "wb");
fwrite(output_self_data, 1, running_size, output_self_file);
fclose(output_self_file);
}
int main(int argc, char* argv[]) {
int i;
u8 ecount_buf[0x10], iv[0x10];
size_t countp;
int num;
if(argc < 4) {
printf("usage: %s input.elf output.self keytype keysuffix\n", argv[0]);
return -1;
}
Elf64_Ehdr input_elf_header;
FILE *input_elf_file = fopen(argv[1], "rb");
fseek(input_elf_file, 0, SEEK_END);
int nlen = ftell(input_elf_file);
fseek(input_elf_file, 0, SEEK_SET);
input_elf_data = (u8*)malloc(nlen);
fread(input_elf_data, 1, nlen, input_elf_file);
fclose(input_elf_file);
memcpy(&input_elf_header, input_elf_data, sizeof(input_elf_header));
FILE *output_self_file = fopen(argv[2], "wb");
printf("ELF header size @ %x\n", get_u16(&(input_elf_header.e_ehsize)) );
printf("%d program headers @ %64llX\n", get_u16(&(input_elf_header.e_phnum)), get_u64(&(input_elf_header.e_phoff)));
printf("%d section headers @ %64llX\n", get_u16(&(input_elf_header.e_shnum)), get_u64(&(input_elf_header.e_shoff)));
Self_Shdr output_self_header; memset(&output_self_header, 0, sizeof(output_self_header));
Self_Ehdr output_extended_self_header; memset(&output_extended_self_header, 0, sizeof(output_extended_self_header));
Self_Ihdr output_self_info_header; memset(&output_self_info_header, 0, sizeof(output_self_info_header));
set_u32(&(output_self_header.s_magic), 0x53434500);
set_u32(&(output_self_header.s_hdrversion), 2);
set_u16(&(output_self_header.s_flags), 1);
set_u16(&(output_self_header.s_hdrtype), 1);
// header size and file size aren't known yet
set_u64(&(output_extended_self_header.e_magic), 3);
set_u64(&(output_extended_self_header.e_ihoff), sizeof(Self_Shdr)+sizeof(Self_Ehdr));
set_u64(&(output_extended_self_header.e_ehoff), sizeof(Self_Shdr)+sizeof(Self_Ehdr)+sizeof(Self_Ihdr));
set_u64(&(output_extended_self_header.e_phoff), sizeof(Self_Shdr)+sizeof(Self_Ehdr)+sizeof(Self_Ihdr)+get_u64(&(input_elf_header.e_phoff)));
// section header offset unknown
set_u64(&(output_self_info_header.i_authid), 0x1070000500000001LL);
set_u32(&(output_self_info_header.i_magic), 0x01000002);
set_u32(&(output_self_info_header.i_apptype), 4);
set_u64(&(output_self_info_header.i_version), 0x0003000000000000LL);
// set static data
int phnum = get_u16(&(input_elf_header.e_phnum));
u32 phsize = (sizeof(Elf64_Phdr)*get_u16(&(input_elf_header.e_phnum)));
Self_SDKversion sdkversion;
Self_Cflags cflags;
memcpy(&sdkversion, sdkversion_static, sizeof(Self_SDKversion));
memcpy(&cflags, cflags_static, sizeof(Self_Cflags));
int running_size = (sizeof(output_self_header)+sizeof(output_extended_self_header)+sizeof(output_self_info_header)+sizeof(input_elf_header)+phsize+0xF)&0xFFFFFFF0;
set_u64(&(output_extended_self_header.e_pmoff), running_size); running_size += phnum*sizeof(Self_PMhdr);
set_u64(&(output_extended_self_header.e_svoff), running_size); running_size += sizeof(Self_SDKversion);
set_u64(&(output_extended_self_header.e_cfoff), running_size); running_size += sizeof(Self_Cflags);
set_u64(&(output_extended_self_header.e_cfsize), sizeof(Self_Cflags));
set_u32(&(output_self_header.s_esize), running_size - sizeof(output_self_header));
printf("running size is %X\n", running_size);
int maxsection = 6;
running_size += sizeof(metadata_crypt_header)+sizeof(segment_certification_header)+maxsection*(sizeof(segment_certification_segment)+sizeof(segment_certification_crypt_encrypted))+sizeof(segment_certification_sign)+sizeof(nubpadding_static);
printf("running size is %X\n", running_size);
set_u64(&(output_self_header.s_shsize), running_size);
// init randomness
gmp_randstate_t r_state;
gmp_randinit_default(r_state);
gmp_randseed_ui(r_state, time(NULL));
// loop through the sections
segment_certification_header segment_header; memset(&segment_header, 0, sizeof(segment_header));
Self_Section first_section;
Self_Section* section_ptr = &first_section;
set_u64(&(segment_header.signature_offset), running_size-sizeof(segment_certification_sign));
set_u32(&(segment_header.unknown1), 1);
set_u32(&(segment_header.segment_count), phnum);
set_u32(&(segment_header.crypt_len), (phnum*sizeof(segment_certification_crypt_encrypted))/0x10);
Elf64_Phdr* elf_segment = (Elf64_Phdr*)(&input_elf_data[get_u64(&(input_elf_header.e_phoff))]);
for(i=0;i<phnum;i++) {
memset(section_ptr, 0, sizeof(Self_Section));
//set_u64(&(section_ptr->enc_segment.segment_offset), get_u64(&(elf_segment->p_vaddr)));
set_u64(&(section_ptr->enc_segment.segment_offset), running_size);
set_u64(&(section_ptr->enc_segment.segment_size), get_u64(&(elf_segment->p_filesz)));
set_u32(&(section_ptr->enc_segment.segment_crypt_flag), 2);
set_u32(&(section_ptr->enc_segment.segment_sha1_index), i*8);
set_u32(&(section_ptr->enc_segment.segment_erk_index), i*8+6);
set_u32(&(section_ptr->enc_segment.segment_riv_index), i*8+7);
set_u32(&(section_ptr->enc_segment.segment_number), i);
set_u32(&(section_ptr->enc_segment.unknown2), 2);
set_u32(&(section_ptr->enc_segment.unknown3), 3);
set_u32(&(section_ptr->enc_segment.unknown4), 2);
set_u64(&(section_ptr->pmhdr.pm_offset), running_size);
set_u64(&(section_ptr->pmhdr.pm_size), get_u64(&(elf_segment->p_filesz)));
set_u32(&(section_ptr->pmhdr.pm_compressed), 1);
set_u32(&(section_ptr->pmhdr.pm_encrypted), 1);
mpz_t riv, erk, hmac;
mpz_init(riv); mpz_init(erk); mpz_init(hmac);
mpz_urandomb(erk, r_state, 128);
mpz_urandomb(riv, r_state, 128);
mpz_urandomb(hmac, r_state, 512);
mpz_export(section_ptr->crypt_segment.erk, &countp, 1, 0x10, 1, 0, erk);
mpz_export(section_ptr->crypt_segment.riv, &countp, 1, 0x10, 1, 0, riv);
mpz_export(section_ptr->crypt_segment.hmac, &countp, 1, 0x40, 1, 0, hmac);
section_ptr->rlen = get_u64(&(elf_segment->p_filesz));
section_ptr->len = ((section_ptr->rlen)+0xF)&0xFFFFFFF0;
section_ptr->data = (u8*)malloc(section_ptr->len);
u32 in_data_offset = get_u64(&(elf_segment->p_offset)); // + get_u16(&(input_elf_header.e_ehsize)) + (sizeof(Elf64_Phdr)*get_u16(&(input_elf_header.e_phnum)));
u8* in_data = &input_elf_data[in_data_offset];
printf("processing segment %d with len %x offset %x\n", i, section_ptr->len, in_data_offset);
//hexdump((u8*)elf_segment, sizeof(Elf64_Phdr));
/*SHA_CTX c;
SHA1_ghetto_init(&c, section_ptr->crypt_segment.hmac);
SHA1_Update(&c, in_data, section_ptr->rlen);
SHA1_ghetto_final(section_ptr->crypt_segment.sha1, &c, section_ptr->crypt_segment.hmac);*/
sha1_hmac(section_ptr->crypt_segment.hmac, in_data, section_ptr->rlen, section_ptr->crypt_segment.sha1);
memset(ecount_buf, 0, 16); num=0;
AES_set_encrypt_key(section_ptr->crypt_segment.erk, 128, &aes_key);
memcpy(iv, section_ptr->crypt_segment.riv, 16);
#ifdef NO_CRYPT
memcpy(section_ptr->data, in_data, section_ptr->len);
#else
//AES_ctr128_encrypt(in_data, section_ptr->data, section_ptr->len, &aes_key, iv, ecount_buf, &num);
aes128ctr((u8*)&aes_key, iv, in_data, section_ptr->len, section_ptr->data);
#endif
running_size += section_ptr->len;
// next
if(i != phnum-1) {
section_ptr->next_section = malloc(sizeof(Self_Section));
}
elf_segment += 1; // 1 is sizeof(Elf64_Phdr)
section_ptr = section_ptr->next_section;
}
printf("segment processing done\n");
// section table offset
set_u64(&(output_extended_self_header.e_shoff), running_size);
// lay out the metadata
u8 metadata[0x2000]; memset(metadata, 0, 0x2000);
u32 metadata_len = 0;
memcpy(&metadata[metadata_len], &output_self_header, sizeof(output_self_header)); metadata_len += sizeof(output_self_header);
memcpy(&metadata[metadata_len], &output_extended_self_header, sizeof(output_extended_self_header)); metadata_len += sizeof(output_extended_self_header);
memcpy(&metadata[metadata_len], &output_self_info_header, sizeof(output_self_info_header)); metadata_len += sizeof(output_self_info_header);
memcpy(&metadata[metadata_len], &input_elf_header, sizeof(input_elf_header)); metadata_len += sizeof(input_elf_header);
memcpy(&metadata[metadata_len], &input_elf_data[get_u64(&(input_elf_header.e_phoff))], phsize); metadata_len += phsize;
metadata_len = (metadata_len+0xF)&0xFFFFFFF0;
section_ptr = &first_section;
while(section_ptr != NULL) {
memcpy(&metadata[metadata_len], &(section_ptr->pmhdr), sizeof(section_ptr->pmhdr)); metadata_len += sizeof(section_ptr->pmhdr);
section_ptr = section_ptr->next_section;
}
memcpy(&metadata[metadata_len], &sdkversion, sizeof(sdkversion)); metadata_len += sizeof(sdkversion);
memcpy(&metadata[metadata_len], &cflags, sizeof(cflags)); metadata_len += sizeof(cflags);
printf("top half of metadata ready\n");
// generate metadata encryption keys
mpz_t bigriv, bigerk;
mpz_init(bigriv); mpz_init(bigerk);
mpz_urandomb(bigerk, r_state, 128);
mpz_urandomb(bigriv, r_state, 128);
metadata_crypt_header md_header;
mpz_export(md_header.erk, &countp, 1, 0x10, 1, 0, bigerk);
mpz_export(md_header.riv, &countp, 1, 0x10, 1, 0, bigriv);
memcpy(&metadata[metadata_len], &md_header, sizeof(md_header)); metadata_len += sizeof(md_header);
memcpy(&metadata[metadata_len], &segment_header, sizeof(segment_header)); metadata_len += sizeof(segment_header);
// copy section data
int csection;
csection = 0;
section_ptr = &first_section;
while(section_ptr != NULL) {
memcpy(&metadata[metadata_len], &(section_ptr->enc_segment), sizeof(section_ptr->enc_segment)); metadata_len += sizeof(section_ptr->enc_segment);
section_ptr = section_ptr->next_section;
if((++csection) == maxsection) break;
}
csection = 0;
section_ptr = &first_section;
while(section_ptr != NULL) {
memcpy(&metadata[metadata_len], &(section_ptr->crypt_segment), sizeof(section_ptr->crypt_segment)); metadata_len += sizeof(section_ptr->crypt_segment);
section_ptr = section_ptr->next_section;
if((++csection) == maxsection) break;
}
// nubpadding time
memcpy(&metadata[metadata_len], nubpadding_static, sizeof(nubpadding_static)); metadata_len += sizeof(nubpadding_static);
// sign shit
u8 digest[0x14];
sha1(metadata, metadata_len, digest);
printf("metadata len is %X\n", metadata_len);
//hexdump(metadata, metadata_len);
//hexdump_nl(digest, 0x14);
segment_certification_sign all_signed;
memset(&all_signed, 0, sizeof(all_signed));
#ifdef GEOHOT_SIGN
mpz_t n,k,da,kinv,r,cs,z;
mpz_init(n); mpz_init(k); mpz_init(da); mpz_init(r); mpz_init(cs); mpz_init(z); mpz_init(kinv);
mpz_import(r, 0x14, 1, 1, 0, 0, appold_R);
mpz_import(n, 0x14, 1, 1, 0, 0, appold_n);
mpz_import(k, 0x14, 1, 1, 0, 0, appold_K);
mpz_import(da, 0x14, 1, 1, 0, 0, appold_Da);
mpz_invert(kinv, k, n);
mpz_import(z, 0x14, 1, 1, 0, 0, digest);
mpz_mul(cs, r, da); mpz_mod(cs, cs, n);
mpz_add(cs, cs, z); mpz_mod(cs, cs, n);
mpz_mul(cs, cs, kinv); mpz_mod(cs, cs, n);
mpz_export(all_signed.R, &countp, 1, 0x14, 1, 0, r);
mpz_export(all_signed.S, &countp, 1, 0x14, 1, 0, cs);
#else
get_keys(argv[3], argv[4]);
//ecdsa_set_curve(appnew_ctype);
//ecdsa_set_pub(appnew_pub);
//ecdsa_set_priv(appnew_priv);
//ecdsa_sign(digest, all_signed.R, all_signed.S);
#endif
memcpy(&metadata[metadata_len], &all_signed, sizeof(all_signed)); metadata_len += sizeof(all_signed);
// encrypt metadata
int metadata_offset = get_u32(&(output_self_header.s_esize)) + sizeof(Self_Shdr);
#ifndef NO_CRYPT
/*memset(ecount_buf, 0, 16); num=0;
AES_set_encrypt_key(&metadata[metadata_offset], 128, &aes_key);
memcpy(iv, &metadata[metadata_offset+0x20], 16);
//AES_ctr128_encrypt(&metadata[0x40+metadata_offset], &metadata[0x40+metadata_offset], metadata_len-metadata_offset-0x40, &aes_key, iv, ecount_buf, &num);
aes128ctr(&metadata[0x20+metadata_offset], &metadata[0x40+metadata_offset], &metadata[0x60+metadata_offset], metadata_len-metadata_offset-0x60, &metadata[0x60+metadata_offset]);
printf("encrypted metadata\n");
//AES_set_encrypt_key(appold_erk, 256, &aes_key);
//memcpy(iv, appold_riv, 16);
AES_set_encrypt_key(appnew_erk, 256, &aes_key);
memcpy(iv, appnew_riv, 16);
//AES_cbc_encrypt(&metadata[metadata_offset], &metadata[metadata_offset], 0x40, &aes_key, iv, AES_ENCRYPT);
aes256cbc_enc(appnew_erk, appnew_riv, &metadata[metadata_offset], 0x40, &metadata[metadata_offset]);
printf("encrypted keys\n");*/
//k.key = appnew_erk;
//k.iv = appnew_riv;
sce_encrypt_header(metadata, &ks);
#endif
// write the output self
fwrite(metadata, 1, metadata_len, output_self_file);
csection = 0;
section_ptr = &first_section;
while(section_ptr != 0) {
printf("writing section with size %X\n", section_ptr->len);
fwrite(section_ptr->data, 1, section_ptr->len, output_self_file);
section_ptr = section_ptr->next_section;
if((++csection) == maxsection) break;
}
fwrite(&input_elf_data[get_u64(&(input_elf_header.e_shoff))], sizeof(Elf64_Shdr), get_u16(&(input_elf_header.e_shnum)), output_self_file);
fclose(output_self_file);
}
static int
get_file_func (CameraFilesystem *fs, const char *folder, const char *filename,
CameraFileType type, CameraFile *file, void *data,
GPContext *context)
{
Camera *camera = data;
int result = GP_ERROR_IO;
enum {
START,
DATA,
ABORT
} state;
int r, pid = 0, update = 0;
uint64_t byteCount = 0;
struct utimbuf mod_utime_buf = { 0, 0 };
char *path;
struct tf_packet reply;
if (type != GP_FILE_TYPE_NORMAL)
return GP_ERROR_NOT_SUPPORTED;
do_cmd_turbo (camera, "ON", context);
path = get_path(camera, folder, filename);
r = send_cmd_hdd_file_send(camera, GET, path, context);
free (path);
if(r < 0)
goto out;
state = START;
while(0 < (r = get_tf_packet(camera, &reply, context)))
{
update = (update + 1) % 4;
switch (get_u32(&reply.cmd)) {
case DATA_HDD_FILE_START:
if(state == START) {
struct typefile *tf = (struct typefile *) reply.data;
byteCount = get_u64(&tf->size);
pid = gp_context_progress_start (context, byteCount, _("Downloading %s..."), filename);
mod_utime_buf.actime = mod_utime_buf.modtime =
tfdt_to_time(&tf->stamp);
send_success(camera,context);
state = DATA;
} else {
gp_log (GP_LOG_ERROR, "topfield", "ERROR: Unexpected DATA_HDD_FILE_START packet in state %d\n", state);
send_cancel(camera,context);
state = ABORT;
}
break;
case DATA_HDD_FILE_DATA:
if(state == DATA) {
uint64_t offset = get_u64(reply.data);
uint16_t dataLen = get_u16(&reply.length) - (PACKET_HEAD_SIZE + 8);
int w;
if (!update) { /* avoid doing it too often */
gp_context_progress_update (context, pid, offset + dataLen);
if (gp_context_cancel (context) == GP_CONTEXT_FEEDBACK_CANCEL) {
send_cancel(camera,context);
state = ABORT;
}
}
if(r < get_u16(&reply.length)) {
gp_log (GP_LOG_ERROR, "topfield", "ERROR: Short packet %d instead of %d\n", r, get_u16(&reply.length));
/* TODO: Fetch the rest of the packet */
}
w = gp_file_append (file, (char*)&reply.data[8], dataLen);
if(w < GP_OK) {
/* Can't write data - abort transfer */
gp_log (GP_LOG_ERROR, "topfield", "ERROR: Can not write data: %d\n", w);
send_cancel(camera,context);
state = ABORT;
}
} else {
gp_log (GP_LOG_ERROR, "topfield", "ERROR: Unexpected DATA_HDD_FILE_DATA packet in state %d\n", state);
send_cancel(camera,context);
state = ABORT;
}
break;
case DATA_HDD_FILE_END:
send_success(camera,context);
result = GP_OK;
goto out;
break;
case FAIL:
gp_log (GP_LOG_ERROR, "topfield", "ERROR: Device reports %s\n", decode_error(&reply));
send_cancel(camera,context);
state = ABORT;
break;
case SUCCESS:
goto out;
break;
default:
gp_log (GP_LOG_ERROR, "topfield", "ERROR: Unhandled packet (cmd 0x%x)\n", get_u32(&reply.cmd));
break;
}
}
if (pid) gp_context_progress_stop (context, pid);
out:
do_cmd_turbo (camera, "OFF", context);
return result;
}
static void avrcp_register_notification_dump(int level, struct frame *frm,
uint8_t ctype, uint16_t len)
{
uint8_t event, status;
uint16_t uid;
uint32_t interval;
uint64_t id;
p_indent(level, frm);
if (ctype > AVC_CTYPE_GENERAL_INQUIRY)
goto response;
if (len < 5) {
printf("PDU Malformed\n");
raw_dump(level, frm);
return;
}
event = get_u8(frm);
printf("EventID: 0x%02x (%s)\n", event, event2str(event));
p_indent(level, frm);
interval = get_u32(frm);
printf("Interval: 0x%08x (%u seconds)\n", interval, interval);
return;
response:
if (len < 1) {
printf("PDU Malformed\n");
raw_dump(level, frm);
return;
}
event = get_u8(frm);
printf("EventID: 0x%02x (%s)\n", event, event2str(event));
p_indent(level, frm);
switch (event) {
case AVRCP_EVENT_PLAYBACK_STATUS_CHANGED:
status = get_u8(frm);
printf("PlayStatus: 0x%02x (%s)\n", status,
playstatus2str(status));
break;
case AVRCP_EVENT_TRACK_CHANGED:
id = get_u64(frm);
printf("Identifier: 0x%jx (%s)\n", id,
id ? "Reserved" : "PLAYING");
break;
case AVRCP_EVENT_PLAYBACK_POS_CHANGED:
interval = get_u32(frm);
printf("Position: 0x%08x (%u miliseconds)\n", interval,
interval);
break;
case AVRCP_EVENT_BATT_STATUS_CHANGED:
status = get_u8(frm);
printf("BatteryStatus: 0x%02x (%s)\n", status,
status2str(status));
break;
case AVRCP_EVENT_SYSTEM_STATUS_CHANGED:
status = get_u8(frm);
printf("SystemStatus: 0x%02x ", status);
switch (status) {
case 0x00:
printf("(POWER_ON)\n");
case 0x01:
printf("(POWER_OFF)\n");
case 0x02:
printf("(UNPLUGGED)\n");
default:
printf("(UNKOWN)\n");
}
break;
case AVRCP_EVENT_PLAYER_APPLICATION_SETTING_CHANGED:
status = get_u8(frm);
printf("AttributeCount: 0x%02x\n", status);
for (; status > 0; status--) {
uint8_t attr, value;
p_indent(level, frm);
attr = get_u8(frm);
printf("AttributeID: 0x%02x (%s)\n", attr,
attr2str(attr));
p_indent(level, frm);
value = get_u8(frm);
printf("ValueID: 0x%02x (%s)\n", value,
value2str(attr, value));
}
break;
case AVRCP_EVENT_VOLUME_CHANGED:
status = get_u8(frm) & 0x7F;
printf("Volume: %.2f%% (%d/127)\n", status/1.27, status);
break;
case AVRCP_EVENT_ADDRESSED_PLAYER_CHANGED:
uid = get_u16(frm);
printf("PlayerID: 0x%04x (%u)\n", uid, uid);
p_indent(level, frm);
uid = get_u16(frm);
printf("UIDCounter: 0x%04x (%u)\n", uid, uid);
break;
}
}
static int bridge_parse_opt(struct link_util *lu, int argc, char **argv,
struct nlmsghdr *n)
{
__u32 val;
while (argc > 0) {
if (matches(*argv, "forward_delay") == 0) {
NEXT_ARG();
if (get_u32(&val, *argv, 0))
invarg("invalid forward_delay", *argv);
addattr32(n, 1024, IFLA_BR_FORWARD_DELAY, val);
} else if (matches(*argv, "hello_time") == 0) {
NEXT_ARG();
if (get_u32(&val, *argv, 0))
invarg("invalid hello_time", *argv);
addattr32(n, 1024, IFLA_BR_HELLO_TIME, val);
} else if (matches(*argv, "max_age") == 0) {
NEXT_ARG();
if (get_u32(&val, *argv, 0))
invarg("invalid max_age", *argv);
addattr32(n, 1024, IFLA_BR_MAX_AGE, val);
} else if (matches(*argv, "ageing_time") == 0) {
NEXT_ARG();
if (get_u32(&val, *argv, 0))
invarg("invalid ageing_time", *argv);
addattr32(n, 1024, IFLA_BR_AGEING_TIME, val);
} else if (matches(*argv, "stp_state") == 0) {
NEXT_ARG();
if (get_u32(&val, *argv, 0))
invarg("invalid stp_state", *argv);
addattr32(n, 1024, IFLA_BR_STP_STATE, val);
} else if (matches(*argv, "priority") == 0) {
__u16 prio;
NEXT_ARG();
if (get_u16(&prio, *argv, 0))
invarg("invalid priority", *argv);
addattr16(n, 1024, IFLA_BR_PRIORITY, prio);
} else if (matches(*argv, "vlan_filtering") == 0) {
__u8 vlan_filter;
NEXT_ARG();
if (get_u8(&vlan_filter, *argv, 0))
invarg("invalid vlan_filtering", *argv);
addattr8(n, 1024, IFLA_BR_VLAN_FILTERING, vlan_filter);
} else if (matches(*argv, "vlan_protocol") == 0) {
__u16 vlan_proto;
NEXT_ARG();
if (ll_proto_a2n(&vlan_proto, *argv))
invarg("invalid vlan_protocol", *argv);
addattr16(n, 1024, IFLA_BR_VLAN_PROTOCOL, vlan_proto);
} else if (matches(*argv, "group_fwd_mask") == 0) {
__u16 fwd_mask;
NEXT_ARG();
if (get_u16(&fwd_mask, *argv, 0))
invarg("invalid group_fwd_mask", *argv);
addattr16(n, 1024, IFLA_BR_GROUP_FWD_MASK, fwd_mask);
} else if (matches(*argv, "group_address") == 0) {
char llabuf[32];
int len;
NEXT_ARG();
len = ll_addr_a2n(llabuf, sizeof(llabuf), *argv);
if (len < 0)
return -1;
addattr_l(n, 1024, IFLA_BR_GROUP_ADDR, llabuf, len);
} else if (matches(*argv, "vlan_default_pvid") == 0) {
__u16 default_pvid;
NEXT_ARG();
if (get_u16(&default_pvid, *argv, 0))
invarg("invalid vlan_default_pvid", *argv);
addattr16(n, 1024, IFLA_BR_VLAN_DEFAULT_PVID,
default_pvid);
} else if (matches(*argv, "mcast_router") == 0) {
__u8 mcast_router;
NEXT_ARG();
if (get_u8(&mcast_router, *argv, 0))
invarg("invalid mcast_router", *argv);
addattr8(n, 1024, IFLA_BR_MCAST_ROUTER, mcast_router);
} else if (matches(*argv, "mcast_snooping") == 0) {
__u8 mcast_snoop;
NEXT_ARG();
if (get_u8(&mcast_snoop, *argv, 0))
invarg("invalid mcast_snooping", *argv);
addattr8(n, 1024, IFLA_BR_MCAST_SNOOPING, mcast_snoop);
} else if (matches(*argv, "mcast_query_use_ifaddr") == 0) {
__u8 mcast_qui;
NEXT_ARG();
if (get_u8(&mcast_qui, *argv, 0))
invarg("invalid mcast_query_use_ifaddr",
*argv);
addattr8(n, 1024, IFLA_BR_MCAST_QUERY_USE_IFADDR,
mcast_qui);
} else if (matches(*argv, "mcast_querier") == 0) {
__u8 mcast_querier;
NEXT_ARG();
if (get_u8(&mcast_querier, *argv, 0))
invarg("invalid mcast_querier", *argv);
addattr8(n, 1024, IFLA_BR_MCAST_QUERIER, mcast_querier);
} else if (matches(*argv, "mcast_hash_elasticity") == 0) {
__u32 mcast_hash_el;
NEXT_ARG();
if (get_u32(&mcast_hash_el, *argv, 0))
invarg("invalid mcast_hash_elasticity",
*argv);
addattr32(n, 1024, IFLA_BR_MCAST_HASH_ELASTICITY,
mcast_hash_el);
} else if (matches(*argv, "mcast_hash_max") == 0) {
__u32 mcast_hash_max;
NEXT_ARG();
if (get_u32(&mcast_hash_max, *argv, 0))
invarg("invalid mcast_hash_max", *argv);
addattr32(n, 1024, IFLA_BR_MCAST_HASH_MAX,
mcast_hash_max);
} else if (matches(*argv, "mcast_last_member_count") == 0) {
__u32 mcast_lmc;
NEXT_ARG();
if (get_u32(&mcast_lmc, *argv, 0))
invarg("invalid mcast_last_member_count",
*argv);
addattr32(n, 1024, IFLA_BR_MCAST_LAST_MEMBER_CNT,
mcast_lmc);
} else if (matches(*argv, "mcast_startup_query_count") == 0) {
__u32 mcast_sqc;
NEXT_ARG();
if (get_u32(&mcast_sqc, *argv, 0))
invarg("invalid mcast_startup_query_count",
*argv);
addattr32(n, 1024, IFLA_BR_MCAST_STARTUP_QUERY_CNT,
mcast_sqc);
} else if (matches(*argv, "mcast_last_member_interval") == 0) {
__u64 mcast_last_member_intvl;
NEXT_ARG();
if (get_u64(&mcast_last_member_intvl, *argv, 0))
invarg("invalid mcast_last_member_interval",
*argv);
addattr64(n, 1024, IFLA_BR_MCAST_LAST_MEMBER_INTVL,
mcast_last_member_intvl);
} else if (matches(*argv, "mcast_membership_interval") == 0) {
__u64 mcast_membership_intvl;
NEXT_ARG();
if (get_u64(&mcast_membership_intvl, *argv, 0))
invarg("invalid mcast_membership_interval",
*argv);
addattr64(n, 1024, IFLA_BR_MCAST_MEMBERSHIP_INTVL,
mcast_membership_intvl);
} else if (matches(*argv, "mcast_querier_interval") == 0) {
__u64 mcast_querier_intvl;
NEXT_ARG();
if (get_u64(&mcast_querier_intvl, *argv, 0))
invarg("invalid mcast_querier_interval",
*argv);
addattr64(n, 1024, IFLA_BR_MCAST_QUERIER_INTVL,
mcast_querier_intvl);
} else if (matches(*argv, "mcast_query_interval") == 0) {
__u64 mcast_query_intvl;
NEXT_ARG();
if (get_u64(&mcast_query_intvl, *argv, 0))
invarg("invalid mcast_query_interval",
*argv);
addattr64(n, 1024, IFLA_BR_MCAST_QUERY_INTVL,
mcast_query_intvl);
} else if (!matches(*argv, "mcast_query_response_interval")) {
__u64 mcast_query_resp_intvl;
NEXT_ARG();
if (get_u64(&mcast_query_resp_intvl, *argv, 0))
invarg("invalid mcast_query_response_interval",
*argv);
addattr64(n, 1024, IFLA_BR_MCAST_QUERY_RESPONSE_INTVL,
mcast_query_resp_intvl);
} else if (!matches(*argv, "mcast_startup_query_interval")) {
__u64 mcast_startup_query_intvl;
NEXT_ARG();
if (get_u64(&mcast_startup_query_intvl, *argv, 0))
invarg("invalid mcast_startup_query_interval",
*argv);
addattr64(n, 1024, IFLA_BR_MCAST_STARTUP_QUERY_INTVL,
mcast_startup_query_intvl);
} else if (matches(*argv, "nf_call_iptables") == 0) {
__u8 nf_call_ipt;
NEXT_ARG();
if (get_u8(&nf_call_ipt, *argv, 0))
invarg("invalid nf_call_iptables", *argv);
addattr8(n, 1024, IFLA_BR_NF_CALL_IPTABLES,
nf_call_ipt);
} else if (matches(*argv, "nf_call_ip6tables") == 0) {
__u8 nf_call_ip6t;
NEXT_ARG();
if (get_u8(&nf_call_ip6t, *argv, 0))
invarg("invalid nf_call_ip6tables", *argv);
addattr8(n, 1024, IFLA_BR_NF_CALL_IP6TABLES,
nf_call_ip6t);
} else if (matches(*argv, "nf_call_arptables") == 0) {
__u8 nf_call_arpt;
NEXT_ARG();
if (get_u8(&nf_call_arpt, *argv, 0))
invarg("invalid nf_call_arptables", *argv);
addattr8(n, 1024, IFLA_BR_NF_CALL_ARPTABLES,
nf_call_arpt);
} else if (matches(*argv, "help") == 0) {
explain();
return -1;
} else {
fprintf(stderr, "bridge: unknown command \"%s\"?\n", *argv);
explain();
return -1;
}
argc--, argv++;
}
return 0;
}
void enumerate_segments() {
int i,num;
size_t countp;
u8 ecount_buf[0x10],iv[0x10];
Self_Segment* segment_ptr = &first_segment;
Elf64_Phdr* elf_segment = (Elf64_Phdr*)(&input_elf_data[get_u64(&(input_elf_header->e_phoff))]);
mpz_t riv, erk, hmac;
mpz_init(riv); mpz_init(erk); mpz_init(hmac);
for(i=0;i<get_u16(&(input_elf_header->e_phnum));i++) {
memset(segment_ptr, 0, sizeof(Self_Segment));
// these are choices you can make
/*segment_ptr->compressed = (i<2);
segment_ptr->incrypt = (i<6); // **TESTING
segment_ptr->encrypted = (i<5);*/
#ifdef NPDRM
segment_ptr->encrypted = (i<5);
segment_ptr->compressed = (i<4);
segment_ptr->incrypt = (i<7);
#else
segment_ptr->encrypted = 1;
segment_ptr->compressed = 1;
segment_ptr->incrypt = 1;
#endif
set_u32(&(segment_ptr->enc_segment.segment_number), i);
set_u32(&(segment_ptr->enc_segment.unknown2), 2);
set_u32(&(segment_ptr->enc_segment.unknown3), 3);
mpz_urandomb(hmac, r_state, 512);
mpz_export(segment_ptr->crypt_segment.hmac, &countp, 1, 0x40, 1, 0, hmac);
if(segment_ptr->encrypted) {
mpz_urandomb(erk, r_state, 128);
mpz_urandomb(riv, r_state, 128);
mpz_export(segment_ptr->crypt_segment.erk, &countp, 1, 0x10, 1, 0, erk);
mpz_export(segment_ptr->crypt_segment.riv, &countp, 1, 0x10, 1, 0, riv);
}
segment_ptr->rlen = get_u64(&(elf_segment->p_filesz));
u32 in_data_offset = get_u64(&(elf_segment->p_offset));
u8* in_data = &input_elf_data[in_data_offset];
if(segment_ptr->compressed) {
int def_size = DEFLATION_BUFFER_SIZE;
printf("deflated...", def(in_data, segment_ptr->rlen, def_buffer, &def_size)); fflush(stdout);
segment_ptr->len = def_size;
segment_ptr->data = (u8*)malloc(segment_ptr->len);
memcpy(segment_ptr->data, def_buffer, def_size);
} else {
segment_ptr->len = segment_ptr->rlen;
segment_ptr->data = (u8*)malloc(segment_ptr->len);
memcpy(segment_ptr->data, in_data, segment_ptr->len);
}
/*if(i==0) {
segment_ptr->padding = 0x26A4;
} else if(i==1) {
segment_ptr->padding = 0xC;
} else {
segment_ptr->padding = 0;
}*/
segment_ptr->padding = (0x10-(segment_ptr->len&0xF))&0xF;
// hacks to make it match
/*if(segment_ptr->len == 0x14BCC8) {
segment_ptr->padding += 0x4330;
}*/
printf("processing segment %d with rlen %x len %x offset %x...", i, segment_ptr->rlen, segment_ptr->len, in_data_offset); fflush(stdout);
//hexdump((u8*)elf_segment, sizeof(Elf64_Phdr));
set_u64(&(segment_ptr->enc_segment.segment_size), segment_ptr->len);
set_u32(&(segment_ptr->enc_segment.segment_crypt_flag), 1+segment_ptr->encrypted);
set_u32(&(segment_ptr->enc_segment.segment_compressed_flag), 1+segment_ptr->compressed);
set_u64(&(segment_ptr->pmhdr.pm_size), segment_ptr->len);
set_u32(&(segment_ptr->pmhdr.pm_compressed), 1+segment_ptr->compressed);
set_u32(&(segment_ptr->pmhdr.pm_encrypted), segment_ptr->encrypted);
// compute sha1
SHA_CTX c;
SHA1_ghetto_init(&c, segment_ptr->crypt_segment.hmac);
SHA1_Update(&c, segment_ptr->data, segment_ptr->len);
SHA1_ghetto_final(segment_ptr->crypt_segment.sha1, &c, segment_ptr->crypt_segment.hmac);
if(segment_ptr->encrypted) {
printf("encrypted..."); fflush(stdout);
memset(ecount_buf, 0, 16); num=0;
AES_set_encrypt_key(segment_ptr->crypt_segment.erk, 128, &aes_key);
memcpy(iv, segment_ptr->crypt_segment.riv, 16);
#ifndef NO_CRYPT
AES_ctr128_encrypt(segment_ptr->data, segment_ptr->data, segment_ptr->len, &aes_key, iv, ecount_buf, &num);
#endif
}
if(i != get_u16(&(input_elf_header->e_phnum))-1) {
segment_ptr->next_segment = malloc(sizeof(Self_Segment));
}
elf_segment += 1; // 1 is sizeof(Elf64_Phdr)
segment_ptr = segment_ptr->next_segment;
printf("\n");
}
}
