typedef unsigned char undefined;
typedef unsigned char byte;
typedef unsigned char dwfenc;
typedef unsigned int dword;
typedef long long longlong;
typedef unsigned long qword;
typedef long sqword;
typedef unsigned char uchar;
typedef unsigned int uint;
typedef unsigned long ulong;
typedef unsigned long long ulonglong;
typedef unsigned char undefined1;
typedef unsigned int undefined4;
typedef unsigned long undefined8;
typedef unsigned short ushort;
typedef unsigned short word;
typedef struct eh_frame_hdr eh_frame_hdr, *Peh_frame_hdr;
struct eh_frame_hdr {
byte eh_frame_hdr_version; // Exception Handler Frame Header Version
dwfenc eh_frame_pointer_encoding; // Exception Handler Frame Pointer Encoding
dwfenc eh_frame_desc_entry_count_encoding; // Encoding of # of Exception Handler FDEs
dwfenc eh_frame_table_encoding; // Exception Handler Table Encoding
};
typedef struct fde_table_entry fde_table_entry, *Pfde_table_entry;
struct fde_table_entry {
dword initial_loc; // Initial Location
dword data_loc; // Data location
};
typedef void _IO_lock_t;
typedef struct _IO_marker _IO_marker, *P_IO_marker;
typedef struct _IO_FILE _IO_FILE, *P_IO_FILE;
typedef long __off_t;
typedef long __off64_t;
typedef ulong size_t;
struct _IO_FILE {
int _flags;
char *_IO_read_ptr;
char *_IO_read_end;
char *_IO_read_base;
char *_IO_write_base;
char *_IO_write_ptr;
char *_IO_write_end;
char *_IO_buf_base;
char *_IO_buf_end;
char *_IO_save_base;
char *_IO_backup_base;
char *_IO_save_end;
struct _IO_marker *_markers;
struct _IO_FILE *_chain;
int _fileno;
int _flags2;
__off_t _old_offset;
ushort _cur_column;
char _vtable_offset;
char _shortbuf[1];
_IO_lock_t *_lock;
__off64_t _offset;
void *__pad1;
void *__pad2;
void *__pad3;
void *__pad4;
size_t __pad5;
int _mode;
char _unused2[20];
};
struct _IO_marker {
struct _IO_marker *_next;
struct _IO_FILE *_sbuf;
int _pos;
};
typedef struct _IO_FILE FILE;
// WARNING! conflicting data type names: /DWARF/__off64_t - /types.h/__off64_t
// WARNING! conflicting data type names: /DWARF/struct_FILE.h/_IO_FILE - /stdio.h/_IO_FILE
// WARNING! conflicting data type names: /DWARF/FILE.h/FILE - /stdio.h/FILE
typedef struct _IO_wide_data _IO_wide_data, *P_IO_wide_data;
struct _IO_wide_data {
};
// WARNING! conflicting data type names: /DWARF/_UNCATEGORIZED_/_IO_marker - /libio.h/_IO_marker
typedef struct _IO_codecvt _IO_codecvt, *P_IO_codecvt;
struct _IO_codecvt {
};
typedef struct evp_pkey_ctx_st evp_pkey_ctx_st, *Pevp_pkey_ctx_st;
struct evp_pkey_ctx_st {
};
typedef struct evp_pkey_ctx_st EVP_PKEY_CTX;
typedef enum Elf64_DynTag {
DT_NULL=0,
DT_NEEDED=1,
DT_PLTRELSZ=2,
DT_PLTGOT=3,
DT_HASH=4,
DT_STRTAB=5,
DT_SYMTAB=6,
DT_RELA=7,
DT_RELASZ=8,
DT_RELAENT=9,
DT_STRSZ=10,
DT_SYMENT=11,
DT_INIT=12,
DT_FINI=13,
DT_SONAME=14,
DT_RPATH=15,
DT_SYMBOLIC=16,
DT_REL=17,
DT_RELSZ=18,
DT_RELENT=19,
DT_PLTREL=20,
DT_DEBUG=21,
DT_TEXTREL=22,
DT_JMPREL=23,
DT_BIND_NOW=24,
DT_INIT_ARRAY=25,
DT_FINI_ARRAY=26,
DT_INIT_ARRAYSZ=27,
DT_FINI_ARRAYSZ=28,
DT_RUNPATH=29,
DT_FLAGS=30,
DT_PREINIT_ARRAY=32,
DT_PREINIT_ARRAYSZ=33,
DT_RELRSZ=35,
DT_RELR=36,
DT_RELRENT=37,
DT_ANDROID_REL=1610612751,
DT_ANDROID_RELSZ=1610612752,
DT_ANDROID_RELA=1610612753,
DT_ANDROID_RELASZ=1610612754,
DT_ANDROID_RELR=1879040000,
DT_ANDROID_RELRSZ=1879040001,
DT_ANDROID_RELRENT=1879040003,
DT_GNU_PRELINKED=1879047669,
DT_GNU_CONFLICTSZ=1879047670,
DT_GNU_LIBLISTSZ=1879047671,
DT_CHECKSUM=1879047672,
DT_PLTPADSZ=1879047673,
DT_MOVEENT=1879047674,
DT_MOVESZ=1879047675,
DT_FEATURE_1=1879047676,
DT_POSFLAG_1=1879047677,
DT_SYMINSZ=1879047678,
DT_SYMINENT=1879047679,
DT_GNU_XHASH=1879047924,
DT_GNU_HASH=1879047925,
DT_TLSDESC_PLT=1879047926,
DT_TLSDESC_GOT=1879047927,
DT_GNU_CONFLICT=1879047928,
DT_GNU_LIBLIST=1879047929,
DT_CONFIG=1879047930,
DT_DEPAUDIT=1879047931,
DT_AUDIT=1879047932,
DT_PLTPAD=1879047933,
DT_MOVETAB=1879047934,
DT_SYMINFO=1879047935,
DT_VERSYM=1879048176,
DT_RELACOUNT=1879048185,
DT_RELCOUNT=1879048186,
DT_FLAGS_1=1879048187,
DT_VERDEF=1879048188,
DT_VERDEFNUM=1879048189,
DT_VERNEED=1879048190,
DT_VERNEEDNUM=1879048191,
DT_AUXILIARY=2147483645,
DT_FILTER=2147483647
} Elf64_DynTag;
typedef enum Elf_ProgramHeaderType {
PT_NULL=0,
PT_LOAD=1,
PT_DYNAMIC=2,
PT_INTERP=3,
PT_NOTE=4,
PT_SHLIB=5,
PT_PHDR=6,
PT_TLS=7,
PT_GNU_EH_FRAME=1685382480,
PT_GNU_STACK=1685382481,
PT_GNU_RELRO=1685382482
} Elf_ProgramHeaderType;
typedef struct Elf64_Shdr Elf64_Shdr, *PElf64_Shdr;
typedef enum Elf_SectionHeaderType {
SHT_NULL=0,
SHT_PROGBITS=1,
SHT_SYMTAB=2,
SHT_STRTAB=3,
SHT_RELA=4,
SHT_HASH=5,
SHT_DYNAMIC=6,
SHT_NOTE=7,
SHT_NOBITS=8,
SHT_REL=9,
SHT_SHLIB=10,
SHT_DYNSYM=11,
SHT_INIT_ARRAY=14,
SHT_FINI_ARRAY=15,
SHT_PREINIT_ARRAY=16,
SHT_GROUP=17,
SHT_SYMTAB_SHNDX=18,
SHT_ANDROID_REL=1610612737,
SHT_ANDROID_RELA=1610612738,
SHT_GNU_ATTRIBUTES=1879048181,
SHT_GNU_HASH=1879048182,
SHT_GNU_LIBLIST=1879048183,
SHT_CHECKSUM=1879048184,
SHT_SUNW_move=1879048186,
SHT_SUNW_COMDAT=1879048187,
SHT_SUNW_syminfo=1879048188,
SHT_GNU_verdef=1879048189,
SHT_GNU_verneed=1879048190,
SHT_GNU_versym=1879048191
} Elf_SectionHeaderType;
struct Elf64_Shdr {
dword sh_name;
enum Elf_SectionHeaderType sh_type;
qword sh_flags;
qword sh_addr;
qword sh_offset;
qword sh_size;
dword sh_link;
dword sh_info;
qword sh_addralign;
qword sh_entsize;
};
typedef struct Elf64_Phdr Elf64_Phdr, *PElf64_Phdr;
struct Elf64_Phdr {
enum Elf_ProgramHeaderType p_type;
dword p_flags;
qword p_offset;
qword p_vaddr;
qword p_paddr;
qword p_filesz;
qword p_memsz;
qword p_align;
};
typedef struct Elf64_Dyn Elf64_Dyn, *PElf64_Dyn;
struct Elf64_Dyn {
enum Elf64_DynTag d_tag;
qword d_val;
};
typedef struct Elf64_Rela Elf64_Rela, *PElf64_Rela;
struct Elf64_Rela {
qword r_offset; // location to apply the relocation action
qword r_info; // the symbol table index and the type of relocation
qword r_addend; // a constant addend used to compute the relocatable field value
};
typedef struct NoteAbiTag NoteAbiTag, *PNoteAbiTag;
struct NoteAbiTag {
dword namesz; // Length of name field
dword descsz; // Length of description field
dword type; // Vendor specific type
char name[4]; // Vendor name
dword abiType; // 0 == Linux
dword requiredKernelVersion[3]; // Major.minor.patch
};
typedef struct GnuBuildId GnuBuildId, *PGnuBuildId;
struct GnuBuildId {
dword namesz; // Length of name field
dword descsz; // Length of description field
dword type; // Vendor specific type
char name[4]; // Vendor name
byte hash[20];
};
typedef struct Elf64_Sym Elf64_Sym, *PElf64_Sym;
struct Elf64_Sym {
dword st_name;
byte st_info;
byte st_other;
word st_shndx;
qword st_value;
qword st_size;
};
typedef struct Elf64_Ehdr Elf64_Ehdr, *PElf64_Ehdr;
struct Elf64_Ehdr {
byte e_ident_magic_num;
char e_ident_magic_str[3];
byte e_ident_class;
byte e_ident_data;
byte e_ident_version;
byte e_ident_osabi;
byte e_ident_abiversion;
byte e_ident_pad[7];
word e_type;
word e_machine;
dword e_version;
qword e_entry;
qword e_phoff;
qword e_shoff;
dword e_flags;
word e_ehsize;
word e_phentsize;
word e_phnum;
word e_shentsize;
word e_shnum;
word e_shstrndx;
};
int _init(EVP_PKEY_CTX *ctx)
{
int iVar1;
iVar1 = __gmon_start__();
return iVar1;
}
void FUN_00401020(void)
{
// WARNING: Treating indirect jump as call
(*(code *)(undefined *)0x0)();
return;
}
// WARNING: Unknown calling convention -- yet parameter storage is locked
int puts(char *__s)
{
int iVar1;
iVar1 = puts(__s);
return iVar1;
}
// WARNING: Unknown calling convention -- yet parameter storage is locked
size_t fread(void *__ptr,size_t __size,size_t __n,FILE *__stream)
{
size_t sVar1;
sVar1 = fread(__ptr,__size,__n,__stream);
return sVar1;
}
// WARNING: Unknown calling convention -- yet parameter storage is locked
int fclose(FILE *__stream)
{
int iVar1;
iVar1 = fclose(__stream);
return iVar1;
}
void __stack_chk_fail(void)
{
// WARNING: Subroutine does not return
__stack_chk_fail();
}
// WARNING: Unknown calling convention -- yet parameter storage is locked
int printf(char *__format,...)
{
int iVar1;
iVar1 = printf(__format);
return iVar1;
}
void __isoc99_sscanf(void)
{
__isoc99_sscanf();
return;
}
// WARNING: Unknown calling convention -- yet parameter storage is locked
FILE * fopen(char *__filename,char *__modes)
{
FILE *pFVar1;
pFVar1 = fopen(__filename,__modes);
return pFVar1;
}
// WARNING: Unknown calling convention -- yet parameter storage is locked
void perror(char *__s)
{
perror(__s);
return;
}
// WARNING: Unknown calling convention -- yet parameter storage is locked
int atoi(char *__nptr)
{
int iVar1;
iVar1 = atoi(__nptr);
return iVar1;
}
void __isoc99_scanf(void)
{
__isoc99_scanf();
return;
}
void processEntry _start(undefined8 param_1,undefined8 param_2)
{
undefined auStack_8 [8];
__libc_start_main(main,param_2,&stack0x00000008,__libc_csu_init,__libc_csu_fini,param_1,auStack_8)
;
do {
// WARNING: Do nothing block with infinite loop
} while( true );
}
void _dl_relocate_static_pie(void)
{
return;
}
// WARNING: Removing unreachable block (ram,0x0040111d)
// WARNING: Removing unreachable block (ram,0x00401127)
void deregister_tm_clones(void)
{
return;
}
// WARNING: Removing unreachable block (ram,0x0040115f)
// WARNING: Removing unreachable block (ram,0x00401169)
void register_tm_clones(void)
{
return;
}
void __do_global_dtors_aux(void)
{
if (completed_8061 == '\0') {
deregister_tm_clones();
completed_8061 = 1;
return;
}
return;
}
void frame_dummy(void)
{
register_tm_clones();
return;
}
// WARNING: Unknown calling convention
void show_flag(void)
{
FILE *__stream;
long lVar1;
undefined8 *puVar2;
long in_FS_OFFSET;
FILE *fp;
char flag [1024];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
flag[0] = '\0';
flag[1] = '\0';
flag[2] = '\0';
flag[3] = '\0';
flag[4] = '\0';
flag[5] = '\0';
flag[6] = '\0';
flag[7] = '\0';
flag[8] = '\0';
flag[9] = '\0';
flag[10] = '\0';
flag[11] = '\0';
flag[12] = '\0';
flag[13] = '\0';
flag[14] = '\0';
flag[15] = '\0';
puVar2 = (undefined8 *)(flag + 0x10);
for (lVar1 = 0x7e; lVar1 != 0; lVar1 = lVar1 + -1) {
*puVar2 = 0;
puVar2 = puVar2 + 1;
}
__stream = fopen("/flag","rb");
if (__stream == (FILE *)0x0) {
puts("Cannot open /flag.");
perror("fopen");
}
else {
fread(flag,0x400,1,__stream);
fclose(__stream);
printf("Your flag: %s\n. Congrats!\n",flag);
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
// WARNING: Subroutine does not return
__stack_chk_fail();
}
return;
}
int verify(EVP_PKEY_CTX *ctx,uchar *sig,size_t siglen,uchar *tbs,size_t tbslen)
{
long lVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
long in_FS_OFFSET;
char *ptr_local;
int n0;
int n1;
int n2;
int n3;
char chunk0 [6];
char chunk1 [6];
char chunk2 [6];
char chunk3 [6];
lVar1 = *(long *)(in_FS_OFFSET + 0x28);
__isoc99_sscanf(ctx,"%5s-%5s-%5s-%5s",chunk0,chunk1,chunk2,chunk3);
iVar2 = atoi(chunk0);
iVar3 = atoi(chunk1);
iVar4 = atoi(chunk2);
iVar5 = atoi(chunk3);
if ((((iVar2 == 0) || (iVar3 == 0)) || (iVar4 == 0)) || (iVar5 == 0)) {
iVar2 = 0;
}
else if ((iVar4 + iVar2 * iVar3) - iVar5 == 0x340fe872) {
if (iVar3 - iVar2 == 0x5ee9) {
if (iVar4 * -5 + iVar5 == -0x5c5c8) {
if ((iVar3 + iVar5) % 100000 == 0x40d3) {
iVar2 = 1;
}
else {
iVar2 = 0;
}
}
else {
iVar2 = 0;
}
}
else {
iVar2 = 0;
}
}
else {
iVar2 = 0;
}
if (lVar1 != *(long *)(in_FS_OFFSET + 0x28)) {
// WARNING: Subroutine does not return
__stack_chk_fail();
}
return iVar2;
}
// WARNING: Unknown calling convention
int main(void)
{
long lVar1;
int iVar2;
uchar *in_RCX;
size_t siglen;
uchar *sig;
size_t in_R8;
long in_FS_OFFSET;
char key [1024];
lVar1 = *(long *)(in_FS_OFFSET + 0x28);
puts("I am happy to see you here! Here is a real challenge for you.");
puts("Give me a valid key, and I will send you a flag!");
sig = (uchar *)key;
__isoc99_scanf(&DAT_004020c9);
iVar2 = verify((EVP_PKEY_CTX *)key,sig,siglen,in_RCX,in_R8);
if (iVar2 == 0) {
puts("Wrong key!");
}
else {
puts("Good job! Go get your flag.");
show_flag();
}
if (lVar1 != *(long *)(in_FS_OFFSET + 0x28)) {
// WARNING: Subroutine does not return
__stack_chk_fail();
}
return 0;
}
void __libc_csu_init(EVP_PKEY_CTX *param_1,undefined8 param_2,undefined8 param_3)
{
long lVar1;
_init(param_1);
lVar1 = 0;
do {
(*(code *)(&__frame_dummy_init_array_entry)[lVar1])((ulong)param_1 & 0xffffffff,param_2,param_3)
;
lVar1 = lVar1 + 1;
} while (lVar1 != 1);
return;
}
void __libc_csu_fini(void)
{
return;
}
void _fini(void)
{
return;
}
Write, Run & Share C Language code online using OneCompiler's C online compiler for free. It's one of the robust, feature-rich online compilers for C language, running the latest C version which is C18. Getting started with the OneCompiler's C editor is really simple and pretty fast. The editor shows sample boilerplate code when you choose language as 'C' and start coding!
OneCompiler's C online editor supports stdin and users can give inputs to programs using the STDIN textbox under the I/O tab. Following is a sample C program which takes name as input and print your name with hello.
#include <stdio.h>
int main()
{
char name[50];
printf("Enter name:");
scanf("%s", name);
printf("Hello %s \n" , name );
return 0;
}
C language is one of the most popular general-purpose programming language developed by Dennis Ritchie at Bell laboratories for UNIX operating system. The initial release of C Language was in the year 1972. Most of the desktop operating systems are written in C Language.
When ever you want to perform a set of operations based on a condition if-else is used.
if(conditional-expression) {
// code
} else {
// code
}
You can also use if-else for nested Ifs and if-else-if ladder when multiple conditions are to be performed on a single variable.
Switch is an alternative to if-else-if ladder.
switch(conditional-expression) {
case value1:
// code
break; // optional
case value2:
// code
break; // optional
...
default:
// code to be executed when all the above cases are not matched;
}
For loop is used to iterate a set of statements based on a condition.
for(Initialization; Condition; Increment/decrement){
// code
}
While is also used to iterate a set of statements based on a condition. Usually while is preferred when number of iterations are not known in advance.
while(condition) {
// code
}
Do-while is also used to iterate a set of statements based on a condition. It is mostly used when you need to execute the statements atleast once.
do {
// code
} while (condition);
Array is a collection of similar data which is stored in continuous memory addresses. Array values can be fetched using index. Index starts from 0 to size-1.
data-type array-name[size];
data-type array-name[size][size];
Function is a sub-routine which contains set of statements. Usually functions are written when multiple calls are required to same set of statements which increases re-usuability and modularity.
Two types of functions are present in C
Library functions are the in-built functions which are declared in header files like printf(),scanf(),puts(),gets() etc.,
User defined functions are the ones which are written by the programmer based on the requirement.
return_type function_name(parameters);
function_name (parameters)
return_type function_name(parameters) {
//code
}