static int unpack_string(grib_accessor*a , char* v, size_t *len){
grib_accessor_md5* self = (grib_accessor_md5*)a;
unsigned mess_len;
unsigned char* mess;
unsigned char* p;
unsigned char digest[16];
long offset,length;
grib_string_list* blacklist=NULL;
grib_accessor* b=NULL;
int ret=0;
char* s=NULL;
int i=0;
struct cvs_MD5Context md5c;
if (*len <32 ) {
grib_context_log(a->parent->h->context,GRIB_LOG_ERROR,"md5: array too small");
return GRIB_ARRAY_TOO_SMALL;
}
if((ret = grib_get_long_internal(a->parent->h,self->offset,&offset))
!= GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(a->parent->h,self->length,&length))
!= GRIB_SUCCESS)
return ret;
mess=grib_context_malloc(a->parent->h->context,length);
memcpy(mess,a->parent->h->buffer->data+offset,length);
mess_len=length;
blacklist=a->parent->h->context->blacklist;
while (blacklist && blacklist->value) {
b=grib_find_accessor(a->parent->h,blacklist->value);
if (!b) return GRIB_NOT_FOUND;
p=mess+b->offset-offset;
for (i=0;i<b->length;i++) *(p++)=0;
blacklist=blacklist->next;
}
cvs_MD5Init(&md5c);
cvs_MD5Update(&md5c,mess,mess_len);
cvs_MD5Final(digest,&md5c);
s=v;
for (i = 0; i < 16; i++)
{
sprintf (s,"%02x", (unsigned int) digest[i]);
s+=2;
}
return ret;
}
/* md5 encrypt a string */
char *md5_hash(const char *string)
{
char *output = calloc(1, 33 * sizeof(char));
struct cvs_MD5Context context;
unsigned char checksum[16];
int i;
cvs_MD5Init (&context);
cvs_MD5Update (&context, string, strlen(string));
cvs_MD5Final (checksum, &context);
for (i = 0; i < 16; i++) {
sprintf(&output[i * 2], "%02x", (unsigned int) checksum[i]);
}
output[32] = '\0';
return output;
}
char *md5_crypt(const char *pw, const char *salt)
{
static char passwd[120], *p;
static const char *sp,*ep;
unsigned char final[16];
size_t sl,i,j;
int pl;
struct cvs_MD5Context ctx,ctx1;
unsigned long l;
/* Refine the Salt first */
sp = salt;
/* If it starts with the magic string, then skip that */
if(!strncmp(sp,magic,strlen(magic)))
sp += strlen(magic);
/* It stops at the first '$', max 8 chars */
for(ep=sp;*ep && *ep != '$' && ep < (sp+8);ep++)
continue;
/* get the length of the true salt */
sl = ep - sp;
cvs_MD5Init(&ctx);
/* The password first, since that is what is most unknown */
cvs_MD5Update(&ctx,pw,strlen(pw));
/* Then our magic string */
cvs_MD5Update(&ctx,magic,strlen(magic));
/* Then the raw salt */
cvs_MD5Update(&ctx,sp,sl);
/* Then just as many characters of the MD5(pw,salt,pw) */
cvs_MD5Init(&ctx1);
cvs_MD5Update(&ctx1,pw,strlen(pw));
cvs_MD5Update(&ctx1,sp,sl);
cvs_MD5Update(&ctx1,pw,strlen(pw));
cvs_MD5Final(final,&ctx1);
for(pl = (int)strlen(pw); pl > 0; pl -= 16)
cvs_MD5Update(&ctx,final,pl>16 ? 16 : pl);
/* Don't leave anything around in vm they could use. */
memset(final,0,sizeof final);
/* Then something really weird... */
for (j=0,i = strlen(pw); i ; i >>= 1)
if(i&1)
cvs_MD5Update(&ctx, final+j, 1);
else
int aos_signature_check(struct aos_signature *sign, const uint8_t *data, unsigned int length)
{
char decrypted[AOS_SIGNATURE_LENGTH];
char reversed[AOS_SIGNATURE_LENGTH];
char digest[16];
struct cvs_MD5Context md5_ctx;
cvs_MD5Init(&md5_ctx);
cvs_MD5Update(&md5_ctx, data, length);
cvs_MD5Final(digest, &md5_ctx);
if(RSA_public_decrypt(AOS_SIGNATURE_LENGTH, sign->data,
decrypted, sign->rsa, RSA_NO_PADDING) == -1)
return 0;
aos_bignum_reverse(decrypted, reversed, AOS_SIGNATURE_LENGTH);
return !memcmp(digest, reversed, sizeof(digest));
}
OM_PRIVATE_FUNC char * __om_digest_md5_file(om_file_input_stream *istream) {
cvs_MD5Context_t ctx;
cvs_MD5Context_t *pctx=&ctx;
memset(pctx,sizeof(cvs_MD5Context_t),0);
unsigned char buffer[OM_DIGEST_BUFFER_LEN_MD5];
memset(buffer,0,OM_DIGEST_BUFFER_LEN_MD5);
int r=0;
unsigned char digest[16];
// update the md5 context for each chunk
// of the md5 context
cvs_MD5Init(pctx);
while( (r=om_storage_read(istream,buffer,OM_DIGEST_BUFFER_LEN_MD5)) && r!=(-1) ) {
// try to align to 32 bits
//int len = r/4;
//if( r%4!=0 ) r+=4;
cvs_MD5Update(pctx,buffer,r);
memset(buffer,0,OM_DIGEST_BUFFER_LEN_MD5);
}
if( r==(-1) )
return OM_NULL;
cvs_MD5Final(digest,pctx);
// put the final md5 sum into a character array
// and pass back
int i;
char * p = om_malloc(33);
if( p==NULL )
return OM_NULL;
unsigned char * ret = p;
memset(p,33,0);
for (i = 0; i < 16; i++) {
sprintf (p, "%02x", digest[i]);
p+=2;
}
return ret;
}
int aes_load_key(unsigned char *key)
{
FILE *fp;
char passphrase[80];
int i;
char chr;
struct cvs_MD5Context ctx;
fp = fopen("wizremote.key", "r");
if(fp == NULL)
{
return 0;
}
for(i=0;i<80;i++)
{
if(fread(&chr, 1, 1, fp) < 1)
break;
if(chr == '\r' || chr == '\n')
break;
passphrase[i] = chr;
}
fclose(fp);
cvs_MD5Init(&ctx);
cvs_MD5Update(&ctx, passphrase, i);
cvs_MD5Final(key, &ctx);
printf("AES key loaded. ");
for(i=0;i < 16;i++)
printf("%x", key[i]);
printf("\n");
return 1;
}
OM_PRIVATE_FUNC char * __om_digest_md5_string(char *str) {
cvs_MD5Context_t ctx;
cvs_MD5Context_t *pctx=&ctx;
memset(pctx,sizeof(cvs_MD5Context_t),0);
unsigned char buffer[OM_DIGEST_BUFFER_LEN_MD5];
memset(buffer,0,OM_DIGEST_BUFFER_LEN_MD5);
int r=0;
unsigned char digest[16];
// update the md5 context for each chunk
// of the md5 context
cvs_MD5Init(pctx);
char *end = str;
end += strlen(str);
for( str=str; str < end; str+=OM_DIGEST_BUFFER_LEN_MD5 ) {
char * new_str = om_string_substr(str, 0, OM_DIGEST_BUFFER_LEN_MD5);
r = strlen(new_str);
cvs_MD5Update(pctx,new_str,r);
om_free(new_str);
}
if( r==(-1) )
return OM_NULL;
cvs_MD5Final(digest,pctx);
// put the final md5 sum into a character array
// and pass back
int i;
char * p = om_malloc(33);
if( p==NULL )
return OM_NULL;
unsigned char * ret = p;
memset(p,33,0);
for (i = 0; i < 16; i++) {
sprintf (p, "%02x", digest[i]);
p+=2;
}
return ret;
}
