Beispiel #1
0
char * prototype_parameter_type(prototype *plist, int pcount, char* function, int pnum, int ptotal) {
    int index=prototypes_find(plist,pcount,function);
    int total_parameters;
    if (index>-1) {
        total_parameters=plist[index].parameters.total_parameters;
        char* rp_type=NULL;
        int i=0;
        for (i=0;i<total_parameters;i++) {
            if (strstr(plist[index].parameters.types[i],"rp")!=NULL) rp_type=plist[index].parameters.types[i];
            if (rp_type==NULL) {
                if (i==pnum) {
                   return strcpy_malloc(plist[index].parameters.types[pnum]);
                }
            }
            else  {
                if (pnum==ptotal-1) {
                    //printf("READ1:%s %d-%d\n",plist[index].parameters.types[pnum],pnum,ptotal);
                    return strcpy_malloc(plist[index].parameters.types[total_parameters-1]);
                }
                else {
                    //printf("READ2:%s\n",rp_type);
                    return strcpy_malloc(rp_type);
                }
            }
        }
    }
    return strcpy_malloc("");
}
Beispiel #2
0
void uprototypes_read_methods(char * file, prototype ** plist, int *pcount) {
    FILE * fp = fopen(file, "r");
    if (fp == NULL) die("Failed to read PHP user method proptypes\n");
    char line[200];
    int i = 0;
    *plist=NULL;
    prototype * list=*plist;
    *pcount=0;
    int methods_started=0;
    for (i = 0; fgets(line,sizeof line,fp)!=NULL; i++) {
        //skip the first part of the file
        if (!methods_started) {
            if (strcmp(line,">methods\n")==0) methods_started=1;
            continue;
        }
        if (line==NULL || strlen(line)<2) break;
        if (line[0]!='\t') {
            (*pcount)++;
            list=(prototype *)realloc(list, (*pcount) * sizeof(prototype));
            if (list == NULL) die("realloc failed\n");
            (list[*pcount-1]).name=strcpy_malloc(line);
            int t=strlen((list[*pcount-1]).name);
            for (t=t;t>=0;t--) {
                if ((list[*pcount-1]).name[t]=='\n') {
                    (list[*pcount-1]).name[t]='\0';
                    break;
                }
            }
            //printf("%s\n",list[*pcount-1]);
            list[*pcount-1].parameters.total_parameters=0;
            list[*pcount-1].parameters.types=NULL;
            list[*pcount-1].return_type=NULL;
        }
        else if (line[0]=='\t' && line[1]!='\t') {
            int total=++(list[*pcount-1].parameters.total_parameters);
            list[*pcount-1].parameters.types=(char **)realloc(list[*pcount-1].parameters.types, total*sizeof(char **) );
            if (list[*pcount-1].parameters.types == NULL) die("realloc failed\n");
            list[*pcount-1].parameters.types[total-1] = strcpy_malloc(&(line[1]));
            //kill the trailing \n;
            list[*pcount-1].parameters.types[total-1][strlen(list[*pcount-1].parameters.types[total-1])-1]='\0';
        }
        else if (line[0]=='\t' && line[1]=='\t') {
            list[*pcount-1].return_type=strcpy_malloc(&(line[2]));
            //kill the trailing \n;
            list[*pcount-1].return_type[strlen(list[*pcount-1].return_type)-1]='\0';
        }
    }
    *plist=list;
    fclose(fp);
}
Beispiel #3
0
/* but not too often */
void request_and_resend (int sock, char * contact, keyset kset)
{
  if (get_counter (contact) <= 0) {
    printf ("unable to request and resend for %s, peer not found\n", contact);
    return;
  }
/*  printf ("request_and_resend (socket %d, peer %s)\n", sock, peer); */
  static char * old_contact = NULL;

  /* if it is the same peer as on the last call, we do nothing */
  if ((old_contact != NULL) && (strcmp (contact, old_contact) == 0)) {
/*    printf ("request_and_resend (%s), same as old peer\n", peer); */
    return;
  }

  if (old_contact != NULL)
    free (old_contact);
  old_contact = strcpy_malloc (contact, "request_and_resend contact");

  /* request retransmission of any missing messages */
  int hops = 10;
  send_retransmit_request (contact, kset, sock, hops,
                           ALLNET_PRIORITY_LOCAL_LOW);

  /* resend any unacked messages, but no more than once every hour */
  static time_t last_resend = 0;
  time_t now = time (NULL);
  if (now - last_resend > 3600) {
    last_resend = now;
    resend_unacked (contact, kset, sock, hops, ALLNET_PRIORITY_LOCAL_LOW, 10);
  }
}
Beispiel #4
0
char * get_filename_only(char * path) {
    char *res;
    int last_slash=0;
    int i;
    for (i=0 ; i<strlen(path) ; i++) {
        if (path[i]=='/') last_slash=i;
    }
    res=strcpy_malloc(path+last_slash+1);
    return res;
}
Beispiel #5
0
char * category_find_guard(taint_category_list *tc_list, char * function, int is_sink) {
    //linear search, I expect taint categories to be very sort.
    for (int i=0; i<tc_list->count; i++) {
        taint_category * tc = tc_list->categories[i];
        if (is_sink) {
            for (int j = 0; j < tc->gcount; j++) {
                if (strcmp(function, tc->glist[j]->name) == 0)
                    return strcpy_malloc(tc->glist[j]->sink);
            }
        }
        else {
            for (int j = 0; j < tc->scount; j++) {
                if (strcmp(function, tc->slist[j]->name) == 0)
                    return strcpy_malloc(tc->slist[j]->sink);
            }
        }
    }
    return NULL;
}
Beispiel #6
0
/*
 * Parsing of console arguments. Plus, copying of the php aspis lib to the output
 */
int my_main(int argc, char* argv[],
        char** aspis_home,
        char** outfilepath_ex,
        char** taintsfilepath_ex,
        char** prototypesfilepath,
        char** categoriesfilepath,
        char** filename) {
    int i;
    printf(">>Parameters used:\n");
    for (i = 0; i < argc; i++)  printf("\t%d. %s\n", i, argv[i]);
    
    //read the configuration parameters from the arguments
    char * m = locate_param(argv, argc, "-mode");
    if (m != NULL) is_online = strcmp(m, "online") == 0;
    else is_online = 0;
    outpath = locate_param(argv, argc, "-out");
    infile = locate_param(argv, argc, "-in");
    fused = locate_param(argv, argc, "-fused");
    taintspath = locate_param(argv, argc, "-taints");
    *prototypesfilepath = locate_param(argv, argc, "-prototypes");
    *categoriesfilepath = locate_param(argv, argc, "-categories");
    *aspis_home=strcpy_malloc(getenv("ASPIS_HOME"));
    
    //stop if help was requested or if we had an invalid configuration    
    int asks_for_help = argc==2 && strcmp(argv[1],"help")==0;
    if (asks_for_help ||  infile==NULL ) {
            if (!is_online) print_usage();
            else exit(1);
    }
    if (fused!=NULL && strcmp(fused,"on")==0) COLLECT_INFO=1;
    
    if (*categoriesfilepath==NULL && !COLLECT_INFO) die("I need a category file.");
    if (infile==NULL) die("I need a file to transform.");
    if (*aspis_home==NULL) die("ASPIS_HOME environmental variable is not set.");
    
    //now set up the environment according to the arguments
    if (!setin(infile)) die(">>Cannot set the infile");
    *filename = infile;
    if (outpath != NULL && !is_online) {
        //construct the output file name. This will have the same name as the input
        //file, but placed inside the outpath directory.
        struct stat st;
        if (!COLLECT_INFO && stat(outpath, &st) != 0) {
            if (mkdir(outpath, 0777)) die("cannot create an outpath");
        }

        char * tok;
        char * inpathc = (char*) malloc((strlen(infile) + 1) * sizeof (char));
        strcpy(inpathc, infile);
        char * name = strtok(inpathc, "/");
        while ((tok = strtok(NULL, "/")) != NULL) {
            name = tok;
        }
        outfile = (char*) malloc((strlen(outpath) + strlen(name) + 200) * sizeof (char));
        strcat(outfile, outpath);
        if (outfile[strlen(outfile - 1)] != '/') strcat(outfile, "/");
        strcat(outfile, name);
        
        if (!COLLECT_INFO) {
           add_runtime_variables(*aspis_home, *categoriesfilepath, 0);
           copy_includes(*aspis_home,*categoriesfilepath);
        }
    } else outfile = outpath;
    if (!is_online) {
        printf("Input File: %s\nOutput Dir:%s\nOutput File:%s\n", infile, outpath, outfile);
        printf("Detected filename: %s\n", infile);
        printf("----------------------------------\n\n");
        fflush(stdout);
    }
    *outfilepath_ex = outfile;
    *taintsfilepath_ex = taintspath;
    return 0;
}
Beispiel #7
0
static int handle_clear (struct allnet_header * hp, char * data, int dsize,
                         char ** contact, char ** message,
                         int * verified, int * broadcast)
{
  if (hp->sig_algo == ALLNET_SIGTYPE_NONE) {
#ifdef DEBUG_PRINT
    printf ("ignoring unsigned clear packet of size %d\n", dsize);
#endif /* DEBUG_PRINT */
    return 0;
  }
  struct allnet_app_media_header * amhp =
    (struct allnet_app_media_header *) data;
  char * verif = data;
  int media = 0;
  if (dsize >= sizeof (struct allnet_app_media_header) + 2)
    media = readb32u (amhp->media);
  if ((media != ALLNET_MEDIA_TEXT_PLAIN) &&
      (media != ALLNET_MEDIA_TIME_TEXT_BIN)) {
#ifdef DEBUG_PRINT
    printf ("handle_clear ignoring unknown media type %08x, dsize %d\n",
            media, dsize);
#endif /* DEBUG_PRINT */
    return 0;
  }
  int ssize = readb16 (data + (dsize - 2)) + 2;  /* size of the signature */
  if ((ssize <= 2) || (dsize <= ssize)) {
    printf ("data packet size %d less than sig %d, dropping\n", dsize, ssize);
    return 0;
  }
  data += sizeof (struct allnet_app_media_header);
  int text_size = dsize - sizeof (struct allnet_app_media_header) - ssize;
  char * sig = data + text_size;
#ifdef DEBUG_PRINT
  printf ("data size %d, text %d + sig %d\n", dsize, text_size, ssize);
#endif /* DEBUG_PRINT */
  struct bc_key_info * keys;
  int nkeys = get_other_keys (&keys);
  int i;
/* print_buffer (verif, dsize - ssize, "verifying BC message", dsize, 1); */
  for (i = 0; i < nkeys; i++) {
    if ((matches ((unsigned char *) (keys [i].address), ADDRESS_BITS,
                  hp->source, hp->src_nbits) > 0) &&
        (allnet_verify (verif, dsize - ssize, sig, ssize - 2,
                        keys [i].pub_key))) {
      *contact = strcpy_malloc (keys [i].identifier,
                                "handle_message broadcast contact");
      *message = malloc_or_fail (text_size + 1, "handle_clear message");
      memcpy (*message, data, text_size);
      (*message) [text_size] = '\0';   /* null-terminate the message */
      *broadcast = 1;
      *verified = 1;
#ifdef DEBUG_PRINT
      printf ("verified bc message, contact %s, %d bytes\n",
              keys [i].identifier, text_size);
#endif /* DEBUG_PRINT */
      return text_size;
    } 
#ifdef DEBUG_PRINT
      else {
      printf ("matches (%02x%02x, %02x%02x/%d) == %d\n",
              keys [i].address [0] & 0xff, keys [i].address [1] & 0xff,
              hp->source [0] & 0xff, hp->source [1] & 0xff, hp->src_nbits,
              matches (keys [i].address, ADDRESS_BITS,
                       hp->source, hp->src_nbits));
      printf ("verify (%p/%d, %p/%d, %p/%d) == %d\n",
              data, dsize - ssize, sig, ssize - 2,
              keys [i].pub_key, keys [i].pub_klen,
              verify (data, dsize - ssize, sig, ssize - 2,
                      keys [i].pub_key, keys [i].pub_klen));
    }
#endif /* DEBUG_PRINT */
  }
  printf ("unable to verify bc message\n");
  return 0;   /* did not match */
}
Beispiel #8
0
//taint category functions
taint_category_list * category_file_read(char * file) {
    taint_category_list *ret=(taint_category_list *)malloc(sizeof(taint_category_list));
    ret->count=0;
    ret->categories=NULL;
    if (file==NULL) return ret;
    FILE * fp = fopen(file, "r");
    
    if (fp == NULL) die("Failed to read the taint category file provided\n");
    char line[200];
    while (fscanf(fp, "%s\n", (char*) line)>0) { //category loop
        if (strcmp(line,"begin")==0) {
            taint_category *tc=(taint_category *)malloc(sizeof(taint_category));
            tc->glist=NULL;
            tc->gcount=0;
            tc->flist=NULL;
            tc->fcount=0;
            tc->slist=NULL;
            tc->scount=0;
            int reading_sanitisation=0;
            int reading_sinks=0;
            int reading_sources=0;
            while (1) { 
                if (fscanf(fp,"%s\n",(char *)line)==0) break;
                if (strcmp(line,"end")==0) break;
                else if (strcmp(line,">sanitisation")==0) {
                    reading_sanitisation=1; 
                    continue;
                }
                else if (strcmp(line,">sinks")==0) {
                    reading_sanitisation=0;
                    reading_sinks=1;
                    continue;
                }
                else if (strcmp(line,">sources")==0) {
                    reading_sanitisation=0;
                    reading_sinks=0;
                    reading_sources=1;
                    continue;
                }
                
                if (reading_sanitisation) { 
                    tc->fcount++;
                    tc->flist=(char **)realloc(tc->flist, tc->fcount * (sizeof(char *)) );
                    if (tc->flist == NULL) die("realloc failed\n");
                    tc->flist[tc->fcount-1]=strcpy_malloc(line);
                }
                else if (reading_sinks || reading_sources) { 
                    char *tok1=strtok((char *)line,"->");
                    char *tok2=strtok((char *)NULL,"->");
                    if (tok1!=NULL && tok2!=NULL) {
                        guard * g=(guard *)malloc(sizeof(guard));
                        g->name = strcpy_malloc(tok1);
                        g->sink = strcpy_malloc(tok2);
                        if (reading_sinks) {
                            tc->gcount++;
                            tc->glist = (guard **) realloc(tc->glist, tc->gcount * (sizeof (guard *)));
                            if (tc->glist == NULL) die("realloc failed\n");
                            tc->glist[tc->gcount - 1] = g;
                        } else if (reading_sources) {
                            tc->scount++;
                            tc->slist = (guard **) realloc(tc->glist, tc->scount * (sizeof (guard *)));
                            if (tc->slist == NULL) die("realloc failed\n");
                            tc->slist[tc->scount - 1] = g;
                        }
                    }
                    else die("Invalid guard in the category file");
                }
            }
            //add to the category list
            ret->count++;
            ret->categories=(taint_category **)realloc(ret->categories, ret->count*sizeof(taint_category *));
            ret->categories[ret->count-1]=tc;
        }
    }
    
    fclose(fp);
    return ret;
}
Beispiel #9
0
char * prototype_return_type(prototype * plist, int pcount, char* function) {
    int index=prototypes_find(plist,pcount,function);
    if (index>-1) return strcpy_malloc(plist[index].return_type);
    else return strcpy_malloc("");
}