genfunc.c

简单的蚂蚁下载

  a = ((a << 0x06) | (a >> 0x1a)) + b; 
  d = ((~c | a) ^ b)  + le2me_32(*((uint32_t*)(param+0x2c))) + d - 0x42C50DCB;
  d = ((d << 0x0a) | (d >> 0x16)) + a; 
  c = ((~b | d) ^ a)  + le2me_32(*((uint32_t*)(param+0x08))) + c + 0x2AD7D2BB;
  c = ((c << 0x0f) | (c >> 0x11)) + d; 
  b = ((~a | c) ^ d)  + le2me_32(*((uint32_t*)(param+0x24))) + b - 0x14792C6F;
  b = ((b << 0x15) | (b >> 0x0b)) + c; 

#ifdef LOG
  printf("real: hash output: %x %x %x %x\n", a, b, c, d);
#endif
  
  a += le2me_32(*((uint32_t *)(field+0)));
  *((uint32_t *)(field+0)) = le2me_32(a);
  b += le2me_32(*((uint32_t *)(field+4)));
  *((uint32_t *)(field+4)) = le2me_32(b);
  c += le2me_32(*((uint32_t *)(field+8)));
  *((uint32_t *)(field+8)) = le2me_32(c);
  d += le2me_32(*((uint32_t *)(field+12)));
  *((uint32_t *)(field+12)) = le2me_32(d);

#ifdef LOG
  printf("real: hash field:\n");
  hexdump(field, 64+24);
#endif
}

static void call_hash (char *key, char *challenge, int len) 
{
  uint32_t *ptr1, *ptr2;
  uint32_t a, b, c, d;
  uint32_t tmp;

  ptr1=(uint32_t*)(key+16);
  ptr2=(uint32_t*)(key+20);
  
  a = le2me_32(*ptr1);
  b = (a >> 3) & 0x3f;
  a += len * 8;
  *ptr1 = le2me_32(a);
  
  if (a < (len << 3))
  {
#ifdef LOG
    printf("not verified: (len << 3) > a true\n");
#endif
    ptr2 += 4;
  }

  tmp = le2me_32(*ptr2);
  tmp += (len >> 0x1d);
  *ptr2 = le2me_32(tmp);
  a = 64 - b;
  c = 0;  
  if (a <= len)
  {

    memcpy(key+b+24, challenge, a);
    hash(key, key+24);
    c = a;
    d = c + 0x3f;
    
    while ( d < len ) {

#ifdef LOG
      printf("not verified:  while ( d < len )\n");
#endif
      hash(key, challenge+d-0x3f);
      d += 64;
      c += 64;
    }
    b = 0;
  }
  
  memcpy(key+b+24, challenge+c, len-c);
}
static void calc_response (char *ret, char *field) {

  char buf1[128];
  char buf2[128];
  int i;

  memset (buf1, 0, 64);
  *buf1 = 128;
  
  memcpy (buf2, field+16, 8);
  
  i = ( le2me_32(*((uint32_t*)(buf2))) >> 3 ) & 0x3f;
 
  if (i < 56) {
    i = 56 - i;
  } else {
#ifdef LOG
    printf("not verified: ! (i < 56)\n");
#endif
    i = 120 - i;
  }

  call_hash (field, buf1, i);
  call_hash (field, buf2, 8);

  memcpy (ret, field, 16);

}

static void calc_response_string (char *result, char *challenge) {
 
  char field[128];
  char zres[20];
  int  i;
      
  /* initialize our field */
  BE_32C (field,      0x01234567);
  BE_32C ((field+4),  0x89ABCDEF);
  BE_32C ((field+8),  0xFEDCBA98);
  BE_32C ((field+12), 0x76543210);
  BE_32C ((field+16), 0x00000000);
  BE_32C ((field+20), 0x00000000);

  /* calculate response */
  call_hash(field, challenge, 64);
  calc_response(zres,field);
 
  /* convert zres to ascii string */
  for (i=0; i<16; i++ ) {
    char a, b;
    
    a = (zres[i] >> 4) & 15;
    b = zres[i] & 15;

    result[i*2]   = ((a<10) ? (a+48) : (a+87)) & 255;
    result[i*2+1] = ((b<10) ? (b+48) : (b+87)) & 255;
  }
}

void real_calc_response_and_checksum (char *response, char *chksum, char *challenge) 
{
  int   ch_len, table_len, resp_len;
  int   i;
  char *ptr;
  char  buf[128];

  /* initialize return values */
  memset(response, 0, 64);
  memset(chksum, 0, 34);

  /* initialize buffer */
  memset(buf, 0, 128);
  ptr=buf;
  BE_32C(ptr, 0xa1e9149d);
  ptr+=4;
  BE_32C(ptr, 0x0e6b3b59);
  ptr+=4;

  /* some (length) checks */
  if (challenge != NULL)
  {
    ch_len = strlen (challenge);

    if (ch_len == 40) /* what a hack... */
    {
      challenge[32]=0;
      ch_len=32;
    }
    if ( ch_len > 56 ) ch_len=56;
    
    /* copy challenge to buf */
    memcpy(ptr, challenge, ch_len);
  }
  
  if (sdd_XorTable != NULL)
  {
    table_len = strlen(sdd_XorTable);

    if (table_len > 56) table_len=56;

    /* xor challenge bytewise with sdd_XorTable */
    for (i=0; i<table_len; i++)
      ptr[i] = ptr[i] ^ sdd_XorTable[i];
  }

  calc_response_string (response, buf);

  /* add tail */
  resp_len = strlen (response);
  strcpy (&response[resp_len], "01d0a8e3");

  /* calculate checksum */
  for (i=0; i<resp_len/4; i++)
    chksum[i] = response[i*4];
}
int GetStartText(char *buf,int sizebuf)
{
    int i;
	//?buf[i + 1] will overflow when i eq (sizebuf - 1)
	//for(i = 0;i <= sizebuf-1;++i)
    for(i = 0;i <= sizebuf-2;++i)
	{
        if(buf[i]=='\n'&&
		  !(buf[i+1] >= 'a'&&buf[i+1] <= 'z'||
			buf[i+1] >= 'A'&&buf[i+1] <= 'Z'))break;
  
    }
    return i+3;
}


int ReadEn(int sock,int n)
{
    fd_set rfdset;
    struct timeval tv;
    tv.tv_sec=n;
    tv.tv_usec=0;
    int readen=0;
    FD_ZERO(&rfdset);
    FD_SET(sock,&rfdset);
    
    readen=select(sock+1,&rfdset,NULL,NULL,&tv);

    return readen;
}

int ConnectHttp(char* host,int iport)
{
    int sd;
    struct sockaddr_in pin;
    struct hostent *nlp_host;

    if((nlp_host = gethostbyname(host))==0)
		sdd_ErrReturn("Error resolving local host\n",0);

    bzero(&pin,sizeof(pin));
    pin.sin_family = AF_INET;
    pin.sin_addr.s_addr = ((struct in_addr*)(nlp_host->h_addr))->s_addr;
    pin.sin_port = htons(iport);
    
    if((sd=socket(PF_INET,SOCK_STREAM,0))==-1)
		sdd_ErrReturn("Error opening socket\n",0);
    if(connect(sd,(struct sockaddr*)&pin,sizeof(pin))==-1)
		sdd_ErrReturn("Error connecting to socket\n",0);

    return sd;
}
//obsolete name
//int GetThreadSize(void)
int GetThreadSize(void)
{
    int threadsize;
    int ntemp;
    int i;
    if((threadsize=(filelength/nthread))>=2048){
        ntemp=threadsize/2048;
        threadsize=ntemp*2048;
    }
    else{
        threadsize=2048;//the least size of each thread
        for(i=1;i<=nthread;i++){
	  if(i*threadsize>=filelength){
	      nthread=i;
	      break;
	  }
        }
    }
    return threadsize;
}