Example #1
0
int ejoy_decrypt_auth_token(const char* token, unsigned int token_sz, const char* svr_pass, 
							unsigned int svr_pass_sz, const char* svr_sig, unsigned int svr_sig_sz, struct ejoy_token* t)
{
	if (token_sz != 160)
	{
		//token长度无效
		return 1;
	}

	char ts[128];
	memcpy(ts, token, 128);
	char tss[16];
	fromhex(token+128, tss, 16);

	MD5_CTX md5;  
	MD5Init(&md5);           
	char decrypt[16];      
	MD5Update(&md5, (unsigned char*)ts, 128); 
	MD5Update(&md5, (unsigned char*)svr_sig, svr_sig_sz);  
	MD5Final(&md5, (unsigned char*)decrypt); 

	for (int i = 0; i < 16; i++)
	{
		if (tss[i] != decrypt[i])
		{
			//token验证失败
			return 1;
		}
	}

	char tsss[64];
	fromhex(token, tsss, 64);
	CRijndael oRijndael;
	oRijndael.MakeKey((char*)svr_pass, NULL, svr_pass_sz, svr_pass_sz);
	char ret[64];
	oRijndael.Decrypt(tsss, ret, 64, CRijndael::ECB);

	char temp[3][64] = {0};
	int index = 0;
	int pos = 0;
	for (int i = 0; i < 64; i++)
	{
		if (ret[i] == '\n')
		{
			index++;
			pos = 0;
		}
		else
		{
			temp[index][pos++] = ret[i]; 
		}
	}

	//token验证成功
	memcpy(t->uid, temp[0], sizeof(t->uid));
	t->timestamp = atol(temp[1]);
	t->randomkey = atol(temp[2]);

	return 0;
}
Example #2
0
static int
lexhexstring(fz_stream *f, char *buf, int n)
{
    char *s = buf;
    char *e = buf + n;
    int a = 0, x = 0;
    int c;

    while (s < e)
    {
        c = fz_readbyte(f);
        switch (c)
        {
        case ISWHITE:
            break;
        case ISHEX:
            if (x)
            {
                *s++ = a * 16 + fromhex(c);
                x = !x;
            }
            else
            {
                a = fromhex(c);
                x = !x;
            }
            break;
        case '>':
        default:
            goto end;
        }
    }
end:
    return s - buf;
}
Example #3
0
static char *
get_spec_by_uuid(const char *s, int *major, int *minor)
{
	unsigned char uuid[16];
	int i;

	if (strlen(s) != 36 || s[8] != '-' || s[13] != '-'
	 || s[18] != '-' || s[23] != '-'
	) {
		goto bad_uuid;
	}
	for (i = 0; i < 16; i++) {
		if (*s == '-')
			s++;
		if (!isxdigit(s[0]) || !isxdigit(s[1]))
			goto bad_uuid;
		uuid[i] = ((fromhex(s[0]) << 4) | fromhex(s[1]));
		s += 2;
	}
	return get_spec_by_x(UUID, (char *)uuid, major, minor);

 bad_uuid:
	fprintf(stderr, _("mount: bad UUID"));
	return 0;
}
Example #4
0
static void
lexname(fz_stream *f, unsigned char *s, int n)
{
	unsigned char *p = s;
	unsigned char *q = s;

	while (n > 1)
	{
		if (!isregular(fz_peekbyte(f)))
			break;
		*s++ = fz_readbyte(f);
		n--;
	}
	*s = '\0';

	while (*p)
	{
		if (p[0] == '#' && p[1] != 0 && p[2] != 0)
		{
			*q++ = fromhex(p[1]) * 16 + fromhex(p[2]);
			p += 3;
		}
		else
			*q++ = *p++;
	}
	*q = '\0';
}
Example #5
0
void
moritz_func(char *in)
{
  if(in[1] == 'r') {                // Reception on
    rf_moritz_init();

  } else if(in[1] == 's' || in[1] == 'f' ) {         // Send/Send fast
    uint8_t dec[MAX_MORITZ_MSG];
    uint8_t hblen = fromhex(in+2, dec, MAX_MORITZ_MSG-1);
    if ((hblen-1) != dec[0]) {
      DS_P(PSTR("LENERR\r\n"));
      return;
    }
    moritz_sendraw(dec, in[1] == 's');

  } else if(in[1] == 'a') {         // Auto-Ack
    fromhex(in+2, autoAckAddr, 3);

  } else if(in[1] == 'w') {         // Fake Wall-Thermostat
    fromhex(in+2, fakeWallThermostatAddr, 3);

  } else {                          // Off
    moritz_on = 0;

  }
}
Example #6
0
/*
 *  rfc1738_unescape() - Converts escaped characters (%xy numbers) in
 *  given the string.  %% is a %. %ab is the 8-bit hexadecimal number "ab"
 */
void
rfc1738_unescape(char *s)
{
    int i, j;			/* i is write, j is read */
    for (i = j = 0; s[j]; i++, j++) {
        s[i] = s[j];
        if (s[j] != '%') {
            /* normal case, nothing more to do */
        } else if (s[j + 1] == '%') {	/* %% case */
            j++;		/* Skip % */
        } else {
            /* decode */
            int v1, v2, x;
            v1 = fromhex(s[j + 1]);
            if (v1 < 0)
                continue;  /* non-hex or \0 */
            v2 = fromhex(s[j + 2]);
            if (v2 < 0)
                continue;  /* non-hex or \0 */
            x = v1 << 4 | v2;
            if (x > 0 && x <= 255) {
                s[i] = x;
                j += 2;
            }
        }
    }
    s[i] = '\0';
}
Example #7
0
static int
lexhexstring(fz_stream *f, unsigned char *buf, int n)
{
	unsigned char *s = buf;
	unsigned char *e = buf + n;
	int a = 0, x = 0;
	int c;

	while (s < e)
	{
		c = fz_readbyte(f);
		if (c == '>')
			break;
		else if (iswhite(c))
			continue;
		else if (ishex(c))
		{
			if (x)
			{
				*s++ = a * 16 + fromhex(c);
				x = !x;
			}
			else
			{
				a = fromhex(c);
				x = !x;
			}
		}
		else
			break;
	}

	return s - buf;
}
Example #8
0
END_TEST

START_TEST(test_bip32_compare)
{
	HDNode node1, node2, node3;
	int i, r;
	hdnode_from_seed(fromhex("301133282ad079cbeb59bc446ad39d333928f74c46997d3609cd3e2801ca69d62788f9f174429946ff4e9be89f67c22fae28cb296a9b37734f75e73d1477af19"), 64, &node1);
	hdnode_from_seed(fromhex("301133282ad079cbeb59bc446ad39d333928f74c46997d3609cd3e2801ca69d62788f9f174429946ff4e9be89f67c22fae28cb296a9b37734f75e73d1477af19"), 64, &node2);
	for (i = 0; i < 300; i++) {
		memcpy(&node3, &node1, sizeof(HDNode));
		r = hdnode_private_ckd(&node1, i); ck_assert_int_eq(r, 1);
		r = hdnode_public_ckd(&node2, i);  ck_assert_int_eq(r, 1);
		r = hdnode_public_ckd(&node3, i);  ck_assert_int_eq(r, 1);
		ck_assert_int_eq(node1.depth,       node2.depth);
		ck_assert_int_eq(node1.depth,       node3.depth);
		ck_assert_int_eq(node1.fingerprint, node2.fingerprint);
		ck_assert_int_eq(node1.fingerprint, node3.fingerprint);
		ck_assert_int_eq(node1.child_num,   node2.child_num);
		ck_assert_int_eq(node1.child_num,   node3.child_num);
		ck_assert_mem_eq(node1.chain_code,  node2.chain_code, 32);
		ck_assert_mem_eq(node1.chain_code,  node3.chain_code, 32);
		ck_assert_mem_eq(node2.private_key, fromhex("0000000000000000000000000000000000000000000000000000000000000000"), 32);
		ck_assert_mem_eq(node3.private_key, fromhex("0000000000000000000000000000000000000000000000000000000000000000"), 32);
		ck_assert_mem_eq(node1.public_key,  node2.public_key, 33);
		ck_assert_mem_eq(node1.public_key,  node3.public_key, 33);
	}
}
Example #9
0
//--------------------------------------------------------------------
void
ccreg(char *in)
{
  uint8_t hb, out, addr;

  if(in[1] == 'w' && fromhex(in+2, &addr, 1) && fromhex(in+4, &hb, 1)) {
    cc1100_writeReg(addr, hb);
    ccStrobe( CC1100_SCAL );
    ccRX();
    DH2(addr); DH2(hb); DNL();

  } else if(fromhex(in+1, &hb, 1)) {

    if(hb == 0x99) {
      for(uint8_t i = 0; i < 0x30; i++) {
        DH2(cc1100_readReg(i));
        if((i&7) == 7)
          DNL();
      }
    } else {
      out = cc1100_readReg(hb);
      DC('C');                    // prefix
      DH2(hb);                    // register number
      DS_P( PSTR(" = ") );
      DH2(out);                  // result, hex
      DS_P( PSTR(" / ") );
      DU(out,2);                  // result, decimal
      DNL();
    }

  }
}
Example #10
0
File: dmx.c Project: Talustus/culfw
void dmx_func(char *in) {
  uint8_t hb[4], d = 0;

  if(in[1] == 'r') {                // print latest record
    memset( hb, 0, sizeof(hb) );
    d = fromhex(in+2, hb, 1);
    if(d) {
       DH2( dmx_get_level( hb[0] ));
       DNL();
    }

  } else if(in[1] == 'w') {

    memset( hb, 0, sizeof(hb) );
    d = fromhex(in+2, hb, 2);
    if(d == 2) {
       dmx_set_level( hb[0], hb[1] );
    }
    if(d > 0) {
       DH2( dmx_get_level( hb[0] ));
       DNL();
    }

  } else if(in[1] == 'c') {
       DU( channel_count, 3 );
       DNL();

  }
}
Example #11
0
END_TEST

START_TEST(test_sign_speed)
{
	uint8_t sig[64], priv_key[32], msg[256];
	size_t i;
	int res;

	for (i = 0; i < sizeof(msg); i++) {
		msg[i] = i * 1103515245;
	}

	clock_t t = clock();

	memcpy(priv_key, fromhex("c55ece858b0ddd5263f96810fe14437cd3b5e1fbd7c6a2ec1e031f05e86d8bd5"), 32);
	for (i = 0 ; i < 250; i++) {
		res = ecdsa_sign(priv_key, msg, sizeof(msg), sig);
		ck_assert_int_eq(res, 0);
	}

	memcpy(priv_key, fromhex("509a0382ff5da48e402967a671bdcde70046d07f0df52cff12e8e3883b426a0a"), 32);
	for (i = 0 ; i < 250; i++) {
		res = ecdsa_sign(priv_key, msg, sizeof(msg), sig);
		ck_assert_int_eq(res, 0);
	}

	printf("Signing speed: %0.2f sig/s\n", 500.0f / ((float)(clock() - t) / CLOCKS_PER_SEC));
}
Example #12
0
static int
logchar (FILE *fp)
{
  int ch;
  int ch2;

  ch = fgetc (fp);
  fputc (ch, stdout);
  fflush (stdout);
  switch (ch)
    {
    case '\n':
      ch = EOL;
      break;
    case '\\':
      ch = fgetc (fp);
      fputc (ch, stdout);
      fflush (stdout);
      switch (ch)
	{
	case '\\':
	  break;
	case 'b':
	  ch = '\b';
	  break;
	case 'f':
	  ch = '\f';
	  break;
	case 'n':
	  ch = '\n';
	  break;
	case 'r':
	  ch = '\r';
	  break;
	case 't':
	  ch = '\t';
	  break;
	case 'v':
	  ch = '\v';
	  break;
	case 'x':
	  ch2 = fgetc (fp);
	  fputc (ch2, stdout);
	  fflush (stdout);
	  ch = fromhex (ch2) << 4;
	  ch2 = fgetc (fp);
	  fputc (ch2, stdout);
	  fflush (stdout);
	  ch |= fromhex (ch2);
	  break;
	default:
	  /* Treat any other char as just itself */
	  break;
	}
    default:
      break;
    }
  return (ch);
}
Example #13
0
File: gdbstub.c Project: Blub/qemu
static void hextomem(uint8_t *mem, const char *buf, int len)
{
    int i;

    for(i = 0; i < len; i++) {
        mem[i] = (fromhex(buf[0]) << 4) | fromhex(buf[1]);
        buf += 2;
    }
}
Example #14
0
int NonBlockInput::doDecode(char* src, char* dev, int* sub, byte* dest)
{
  int ret;
  int count;
  int len;
  bool isHex; // HEX->Binary conversion
  char* start = src;
  byte cs = 0;
  byte cs2;
  int i;

  *dev++ = *src++;
  *dev++ = *src++;
  *dev   = '\0';
  if (' ' != *src++) return -1;
  *sub = *src++ - '0';
  if (' ' != *src++) return -2;
  isHex = ('-' == *src);
  if (isHex) src++;
  len = atoi(src);
  count = 1;
  if (len > 9) count = 2;
  if (len > 99) count = 3;
  if (len > 999) count = 4;
  src += count;
  if (' ' != *src++) return -3;
  if (isHex) {
    count++; // allow for '-'
    int b;
    for (i=0; i<len; i++) {
      if (-1 == (b = fromhex(src))) return -4;
      *dest++ = b;
      src+=2;
      if (' ' != *src++) return -5;
    }
    ret = len;
    count += 3+2+(3*len);
  } else {
    for (i=0; i<len; i++) *dest++ = *src++;
    if (' ' != *src++) return -7;
    ret = len;
    count += 3+2+1+len;
  }
  for (i=0; i<count; i++) cs += start[i];
  cs2 = fromhex(src);
  if (0 != (0xFF & (cs + cs2))) {
    Serial.print("doDecode: ");
    Serial.print(cs, HEX);
    Serial.print(" + ");
    Serial.print(cs2, HEX);
    Serial.print(" = ");
    Serial.println(cs+cs2, HEX);
    return -8;
  }
  return ret;
}
Example #15
0
int main() {
    char test[]  = "deadbeef";
    char test2[] = "0xcafebabe";
    char test3[] = "yo mama";

    printf("%s = %lu\n%s = %lu\n%s = %lu\n",
            test, fromhex(test),
            test2, fromhex(test2),
            test3, fromhex(test3)
          );
    return 0;
}
Example #16
0
void
write_eeprom(char *in)
{
  uint8_t hb[6], d = 0;

#ifdef HAS_ETHERNET
  if(in[1] == 'i') {
    uint8_t *addr = 0;
           if(in[2] == 'm') { d=6; fromhex(in+3,hb,6); addr=EE_MAC_ADDR;
    } else if(in[2] == 'd') { d=1; fromdec(in+3,hb);   addr=EE_USE_DHCP;
    } else if(in[2] == 'a') { d=4; fromip (in+3,hb,4); addr=EE_IP4_ADDR;
    } else if(in[2] == 'n') { d=4; fromip (in+3,hb,4); addr=EE_IP4_NETMASK;
    } else if(in[2] == 'g') { d=4; fromip (in+3,hb,4); addr=EE_IP4_GATEWAY;
    } else if(in[2] == 'p') { d=2; fromdec(in+3,hb);   addr=EE_IP4_TCPLINK_PORT;
    } else if(in[2] == 'N') { d=4; fromip (in+3,hb,4); addr=EE_IP4_NTPSERVER;
    } else if(in[2] == 'o') { d=1; fromhex(in+3,hb,1); addr=EE_IP4_NTPOFFSET;
#ifdef HAS_NTP
      extern int8_t ntp_gmtoff;
      ntp_gmtoff = hb[0];
#endif
    }
    for(uint8_t i = 0; i < d; i++)
      ewb(addr++, hb[i]);

  } else 
#endif
  {
    uint16_t addr;
    d = fromhex(in+1, hb, 3);
    if(d < 2)
      return;
    if(d == 2)
      addr = hb[0];
    else
      addr = (hb[0] << 8) | hb[1];
      
    ewb((uint8_t*)addr, hb[d-1]);

    if (addr == 15 || addr == 16 || addr == 17)
      checkFrequency();

    // If there are still bytes left, then write them too
    in += (2*d+1);
    while(in[0]) {
      addr++;
      if(!fromhex(in, hb, 1))
        return;
      ewb((uint8_t*)addr++, hb[0]);
      in += 2;
    }
  }
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void CCertUtils::ConvHex (BYTE  *pIn,
                        DWORD  dwLen,
                        BYTE  *pOut
                       )
{
#define fromhex(x) (x-((x>='0')&&(x<='9')?'0':((x>='A')&&(x<='F')?'7':'W')))
   register DWORD i;

   for(i=0; i < dwLen; i+=2)
   {
      pOut[ i / 2 ] = ( BYTE )( ( fromhex( pIn[ i ] ) << 4 ) + fromhex( pIn[ i + 1 ] ) );
   }
}
unsigned int scan_ip6_flat(const char *s,char ip[16])
{
  int i;
  for (i=0; i<16; i++) {
    int tmp;
    tmp=fromhex(*s++);
    if (tmp<0) return 0;
    ip[i]=tmp << 4;
    tmp=fromhex(*s++);
    if (tmp<0) return 0;
    ip[i]+=tmp;
  }
  return 32;
}
ssize_t scan_urlencoded_query(char **string, char *deststring, SCAN_SEARCHPATH_FLAG flags) {
  const unsigned char* s=*(const unsigned char**) string;
  unsigned char *d = (unsigned char*)deststring;
  unsigned char b, c, f;

  /* This is the main decoding loop.
    'flag' determines, which characters are non-terminating in current context
    (ie. stop at '=' and '&' if scanning for a 'param'; stop at '?' if scanning for the path )
  */
  while( ( f = is_unreserved[ c = *s++ ] ) & flags ) {

    /* When encountering an url escaped character, try to decode */
    if( c=='%') {
      if( ( b = fromhex(*s++) ) == 0xff ) return -1;
      if( ( c = fromhex(*s++) ) == 0xff ) return -1;
      c|=(b<<4);
    }

    /* Write (possibly decoded) character to output */
    *d++ = c;
  }

  switch( c ) {
  case 0: case '\r': case '\n': case ' ':
    /* If we started scanning on a hard terminator, indicate we've finished */
    if( d == (unsigned char*)deststring ) return -2;

    /* Else make the next call to scan_urlencoded_param encounter it again */
    --s;
    break;
  case '?':
    /* XXX to help us parse path?param=value?param=value?... sent by µTorrent 1600
       do not return an error but silently terminate
    if( flags != SCAN_PATH ) return -1; */
    break;
  case '=':
    if( flags != SCAN_SEARCHPATH_PARAM ) return -1;
    break;
  case '&':
    if( flags == SCAN_PATH ) return -1;
    if( flags == SCAN_SEARCHPATH_PARAM ) --s;
    break;
  default:
    return -1;
  }

  *string = (char *)s;
  return d - (unsigned char*)deststring;
}
Example #20
0
/////////////////////////////////////////////////////////////////////
// First byte, hex: Row number if less then 32, Display text in title else
// Rest: Text to display, up to 16 char.
// 00:title (big font).
// 01-08:body
// 09:scroll up, add row at bottom
// 0A:scroll down, add row at top
// 0B:redraw screen.
// FF:control functions: Switch LCD on/of, set contrast
void
lcdfunc(char *in)
{
  uint8_t hb[4];
  uint8_t narg = fromhex(in+1, hb, 4);

  if(narg > 0 && hb[0] == 0xFF) {

    if(hb[1] != 0xFF) lcd_switch(hb[1]);
    if(hb[2] != 0xFF) lcd_contrast(hb[2]);
#ifdef LCD_BL_PWM
    if(hb[3] != 0xFF) lcd_brightness(hb[3]);
#endif

    return;
  }

  if(narg == 0 || hb[0] >=  0x20) {   // Strange lines go to the title
    hb[0] = 0;
    in += 1;
  } else {
    in += 3;
  }
  lcd_putline(hb[0], in);
}
static char *hex2strn(const char *data, const int len)
{
	if (len == 0) {
		return NULL;
	}
	int i, j;
	int result_len = len/2 + 1;

	char *result = (char *)malloc((result_len + 1) * sizeof(char));

	for (i=0, j=0; i<len; i+=2) {
		result[j++] = fromhex(data[i]) << 4 | fromhex(data[i+1]);
	}
	result[j] = 0x00;
	return result;
}
Example #22
0
//--------------------------------------------------------------------
void
ccreg(char *in)
{
  uint8_t hb, out;

  if(fromhex(in+1, &hb, 1)) {

    if(hb == 0x99) {
      for(uint8_t i = 0; i < 0x30; i++) {
        DH2(cc1100_readReg(i));
        if((i&7) == 7)
          DNL();
      }
    } else {
      out = cc1100_readReg(hb);
      DC('C');                    // prefix
      DH2(hb);                    // register number
      DS_P( PSTR(" = ") );
      DH2(out);                  // result, hex
      DS_P( PSTR(" / ") );
      DU(out,2);                  // result, decimal
      DNL();
    }

  }
}
Example #23
0
// LED
void
ledfunc(char *in)
{
  fromhex(in+1, &led_mode, 1);
#ifdef XLED
  switch (led_mode) {
    case 0:
      xled_pattern = 0; 
      break;
    case 1:
      xled_pattern = 0xffff; 
      break;
    case 2:
      xled_pattern = 0xff00; 
      break;
    case 3:
      xled_pattern = 0xa000; 
      break;
    case 4:
      xled_pattern = 0xaa00; 
      break;
  }
#else
  if(led_mode & 1)
    LED_ON();
  else
    LED_OFF();
#endif

  ewb(EE_LED, led_mode);
}
Example #24
0
uint8_t is_dcon_frame( uint8_t *cp, uint8_t len )
{
    if( cp[len-1] != 0x0D )
        return 0;

    switch( *cp )
    {
    case '$':
    case '#':
    case '%':
    case '@':
    case '*':
        break;

    default:
        return 0;
    }

    uint8_t recv_crc = fromhex( cp+len-3 );

    uint8_t calc_crc = dcon_checksum( cp, len - 3 );

    if( calc_crc != recv_crc )
    {
        modbus_crc_cnt++;
        return 0;
    }

    return 1;
}
Example #25
0
File: dmx.c Project: Talustus/culfw
int dmx_fs20_emu(char *in) {
  uint8_t hb[4], d = 0;

#ifdef DMX_FS20EMU_HC
  if (!strncmp(in+1, DMX_FS20EMU_HC, 4)) {
    memset( hb, 0, sizeof(hb) );
    d = fromhex(in+5, hb, 2);
    if(d == 2) {
      switch (hb[1]) {
        case 0:
          break;
        case 0x1 ... 0xf:
          hb[1] <<= 4;
          break;
        case 0x10:
        case 0x11:
          hb[1] = 0xff;
          break;
        default:
          return 1;
      }
      dmx_set_level( hb[0], hb[1] );
      return 1;
    }
  }
Example #26
0
static int
readahxd(fz_stream *stm, unsigned char *buf, int len)
{
    fz_ahxd *state = stm->state;
    unsigned char *p = buf;
    unsigned char *ep = buf + len;
    int a, b, c, odd;

    odd = 0;

    while (p < ep)
    {
        if (state->eod)
            return p - buf;

        c = fz_readbyte(state->chain);
        if (c < 0)
            return p - buf;

        if (ishex(c))
        {
            if (!odd)
            {
                a = fromhex(c);
                odd = 1;
            }
            else
            {
                b = fromhex(c);
                *p++ = (a << 4) | b;
                odd = 0;
            }
        }
        else if (c == '>')
        {
            if (odd)
                *p++ = (a << 4);
            state->eod = 1;
        }
        else if (!iswhite(c))
        {
            return fz_throw("bad data in ahxd: '%c'", c);
        }
    }

    return p - buf;
}
Example #27
0
static char *get_path(struct request *req, char **host, char **http)
{
	char *ret, *in, *out;
	if(!strncmp("http://", req->buf + req->cur, 7)) {
		char *slash;
		req->cur += 7;
		*host = req->buf + req->cur;
		slash = strpbrk(req->buf + req->cur, "/ \r\n");
		if(!slash || *slash != '/') return 0;
		req->cur += slash - (req->buf + req->cur);
	}

	ret = req->buf + req->cur;

	for(in = out = ret; *in != ' ' && *in != '\r' && *in != '\n' ; in++, out++) {
		if(*in == '%') {
			int n;
			char c = 0;
			if(!*++in) return 0;
			if(!in[1]) return 0;
			n = fromhex(*in);
			if(n < 0) return 0;
			c = n << 4;
			n = fromhex(*++in);
			if(n < 0) return 0;
			c |= n;
			if(c == '/') return 0;
			*out = c;
		} else {
			*out = *in;
		}
	}

	in++;
	*http = in;
	for(; *in != '\r' && *in != '\n'; in++);
	*in = '\0';
	if(strcmp(*http, "") == 0) *http = "HTTP/0.9";

	req->cur += in - (req->buf + req->cur);
	req->cur++;
	if(req->buf[req->cur] == '\n') req->cur++;

	*out = '\0';
	return ret;
}
Example #28
0
//--------------------------------------------------------------------
void
ccsetpa(char *in)
{
  uint8_t hb = 2;
  fromhex(in+1, &hb, 1);
  cc_set_pa(hb);
  ccInitChip(EE_CC1100_CFG);
}
Example #29
0
int helios_fs20_emu(char *in) {
  uint8_t hb[4], d = 0;

#ifdef HELIOS_EMU_HC
  if (!strncmp(in+1, HELIOS_EMU_HC, 4)) {
    memset( hb, 0, sizeof(hb) );
    d = fromhex(in+5, hb, 2);
    if(d == 2) {
      switch (hb[1]) {
        case 0:
	  helios_set( 0x29, 0 );
          break;
        case 0x1:
        case 0x2:
	  helios_set( 0x29, 1 );
          break;
        case 0x3:
        case 0x4:
	  helios_set( 0x29, 3 );
          break;
        case 0x5:
        case 0x6:
	  helios_set( 0x29, 7 );
          break;
        case 0x7:
        case 0x8:
	  helios_set( 0x29, 0xf );
          break;
        case 0x9:
        case 0xa:
	  helios_set( 0x29, 0x1f );
          break;
        case 0xb:
        case 0xc:
	  helios_set( 0x29, 0x3f );
          break;
        case 0xd:
        case 0xe:
	  helios_set( 0x29, 0x7f );
          break;
        case 0xf:
        case 0x10:
        case 0x11:
	  helios_set( 0x29, 0xff );
          break;
        default:
          return 1;
      }
      return 1;
    }
  }
#endif

  return 0;
}
Example #30
0
int
fDns_read_secret(const char *filename)
{
//    fprintf(stderr, "(%s:%s:%i) filename: '%s'\n", __FILE__, __func__, __LINE__, filename);

    file = fopen(filename, "r");
    if (file == NULL) {
        fprintf(stderr, "(%s:%s:%i) errno: '%s'\n", __FILE__, __func__, __LINE__, strerror(errno));
        return -1;
    }

    while ((read = getline(&line, &len, file)) != -1) {
        sl = strlen(line);
//        fprintf(stderr, "(%s:%s:%i) '%.*s' sl: %u\n", __FILE__, __func__, __LINE__, sl - 1, line, sl);
        if (sl > 63) {
            //check if 64 bytes hex...
            if (fromhex((const unsigned char *)line, &dnscurve_keys[1 + dnscurve_keys_len].server_secretkey[0])) {
                rc = crypto_scalarmult_curve25519_base(&dnscurve_keys[1 + dnscurve_keys_len].server_publickey[0], &dnscurve_keys[1 + dnscurve_keys_len].server_secretkey[0]);
                if (rc != 0) {
                    explicit_bzero((void *)&dnscurve_keys[1 + dnscurve_keys_len].server_secretkey[0], crypto_box_curve25519xsalsa20poly1305_SECRETKEYBYTES);
                    fprintf(stderr, "(%s:%s:%i) (crypto_scalarmult_curve25519_base) rc: %i\n", __FILE__, __func__, __LINE__, rc);
                } else {
                    dnscurve_keys[1 + dnscurve_keys_len].hash = fDns_hash_fnv64(&dnscurve_keys[1 + dnscurve_keys_len].server_publickey[0], crypto_box_curve25519xsalsa20poly1305_PUBLICKEYBYTES);
                    printf("Using hash: '%lu' for public key for host: ", dnscurve_keys[1 + dnscurve_keys_len].hash);
                    for (rc = 0; rc < crypto_box_curve25519xsalsa20poly1305_PUBLICKEYBYTES; rc++) {
                        printf("%02x", dnscurve_keys[1 + dnscurve_keys_len].server_publickey[rc]);
                    }
                    printf("\n");

                    dnscurve_keys_len++;

                    if (dnscurve_keys_len == DNSCURVE_KEYS_SIZE) {
                        fprintf(stderr, "(%s:%s:%i) Reached the limit of '%i' keys.\n", __FILE__, __func__, __LINE__, dnscurve_keys_len);
                        break;
                    }
                }
            }
        }

        explicit_bzero((void *)line, len);

        len = 0;
        if (line != NULL)
            free(line);
        line = NULL;
    }

    if (dnscurve_keys_len) {
        //the first read secret key is also the DNScurve key.
        fDns_dnscurve_the_key = &dnscurve_keys[1];
    }

    fclose(file);
    return 0;
}