void iWA_Crypto_Sha1Interleave(SHA1Context *sha_ctx, BIGNUM *result, BIGNUM *input)
{
#define iWAmacro_CRYPTO_SHA1_INTERLEAVE_INPUT_SIZE (32)
#define iWAmacro_CRYPTO_SHA1_INTERLEAVE_RESULT_SIZE (40)
iWAuint8 t[iWAmacro_CRYPTO_SHA1_INTERLEAVE_INPUT_SIZE];
iWAuint8 t1[iWAmacro_CRYPTO_SHA1_INTERLEAVE_INPUT_SIZE/2];
iWAuint8 digest[SHA1HashSize];
iWAuint8 vK[iWAmacro_CRYPTO_SHA1_INTERLEAVE_RESULT_SIZE];
iWAint32 i, j;
BN_bn2bin(input, t);
for(i = 0, j = sizeof(t1) - 1; j >= 0; i++, j--) t1[j] = t[i * 2];
SHA1Reset(sha_ctx);
SHA1Input(sha_ctx, t1, sizeof(t1));
SHA1Result(sha_ctx, digest);
for(i = 0, j = SHA1HashSize - 1; j >= 0; i++, j--) vK[i*2] = digest[j];
for(i = 0, j = sizeof(t1) - 1; j >= 0; i++, j--) t1[j] = t[i * 2 + 1];
SHA1Reset(sha_ctx);
SHA1Input(sha_ctx, t1, sizeof(t1));
SHA1Result(sha_ctx, digest);
for(i = 0, j = SHA1HashSize - 1; j >= 0; i++, j--) vK[i*2 + 1] = digest[j];
BN_bin2bn(vK, iWAmacro_CRYPTO_SHA1_INTERLEAVE_RESULT_SIZE, result);
}
void OAuth::HMAC_SHA1(SHA1DG dst, const char* key, int klen, const char* src, int n) {
char tmp_key[128];
if(klen > 64) {
SHA1DG keydg;
SHA1Context sha;
SHA1Reset(&sha);
SHA1Input(&sha, (const uint8_t*)key, klen);
SHA1Result(&sha, keydg);
HMAC_SHA1(dst, (const char*)keydg, 20, src, n);
return;
}
memcpy(tmp_key, key, klen);
for(int i=klen ; i<64+1 ; i++)
tmp_key[i] = 0x00;
char tmp_0[64], tmp_1[64];
for(int i=0 ; i<64 ; i++) {
tmp_0[i] = tmp_key[i] ^ 0x5c;
tmp_1[i] = tmp_key[i] ^ 0x36;
}
SHA1Context sha;
SHA1Reset(&sha);
SHA1Input(&sha, (const uint8_t*)tmp_1, 64);
SHA1Input(&sha, (const uint8_t*)src, n);
SHA1Result(&sha, dst);
SHA1Reset(&sha);
SHA1Input(&sha, (const uint8_t*)tmp_0, 64);
SHA1Input(&sha, dst, 20);
SHA1Result(&sha, dst);
}
void nls_get_x(nls_t* nls, mpz_t x_c, const char* raw_salt) {
char* userpass;
uint8_t hash[20], final_hash[20];
SHA1Context shac;
// build the string Username:Password
userpass = (char*) malloc(nls->username_len + nls->password_len + 2);
memcpy(userpass, nls->username, nls->username_len);
userpass[nls->username_len] = ':';
memcpy(userpass + nls->username_len + 1, nls->password, nls->password_len);
userpass[nls->username_len + nls->password_len + 1] = 0; // null-terminator
// get the SHA-1 hash of the string
SHA1Reset(&shac);
SHA1Input(&shac, (uint8_t*) userpass,
(nls->username_len + nls->password_len + 1));
SHA1Result(&shac, hash);
free(userpass);
// get the SHA-1 hash of the salt and user:pass hash
SHA1Reset(&shac);
SHA1Input(&shac, (uint8_t*) raw_salt, 32);
SHA1Input(&shac, hash, 20);
SHA1Result(&shac, final_hash);
SHA1Reset(&shac);
// create an arbitrary-length integer from the hash and return it
mpz_init2(x_c, 160);
mpz_import(x_c, 20, -1, 1, 0, 0, (char*) final_hash);
}
void hmac_final(hmac_ctx *ctx, unsigned char *hmac)
{
int i;
unsigned char hash[0x14];
SHA1Result(&ctx->hash_ctx);
// this sha1 implementation is buggy, needs to switch endian
for(i=0; i<5; ++i) {
wbe32(hash + 4*i, ctx->hash_ctx.Message_Digest[i]);
}
for(i=0; i<0x40; ++i)
ctx->key[i] ^= 0x36^0x5c; // opad
SHA1Reset(&ctx->hash_ctx);
SHA1Input(&ctx->hash_ctx,ctx->key,0x40);
SHA1Input(&ctx->hash_ctx,hash,0x14);
SHA1Result(&ctx->hash_ctx);
for(i=0; i<5; ++i) {
wbe32(hash + 4*i, ctx->hash_ctx.Message_Digest[i]);
}
memcpy(hmac, hash, 20);
}
void HMAC_SHA1( unsigned char *result,
unsigned char *key, int key_length,
unsigned char *text1, int text1_length,
unsigned char *text2, int text2_length )
{
unsigned char state1[0x40];
unsigned char state2[0x40+0x14];
int i;
struct SHA1Context context;
for(i=0x40-1; i>=key_length;--i) state1[i] = 0x36;
for(;i>=0;--i) state1[i] = key[i] ^ 0x36;
SHA1Reset(&context);
SHA1Input(&context,state1,0x40);
SHA1Input(&context,text1,text1_length);
SHA1Input(&context,text2,text2_length);
SHA1Result(&context,&state2[0x40]);
for(i=0x40-1; i>=key_length;--i) state2[i] = 0x5C;
for(;i>=0;--i) state2[i] = key[i] ^ 0x5C;
SHA1Reset(&context);
SHA1Input(&context,state2,0x40+0x14);
SHA1Result(&context,result);
}
static int sha1_hmac( lua_State *L )
{
SHA1Context sha1,sha2;
char key[BLOCKSIZE];
char hash[SHA1_LEN];
int i;
size_t len;
const char *secret,*msg;
luaL_checkstring(L,1);
msg = luaL_checkstring(L,2);
//Get length from LUA (may contain zeroes)
secret = lua_tolstring(L,1,&len);
//Fill with zeroes
memset(key, 0, BLOCKSIZE);
if (len > BLOCKSIZE) {
//Too long key, shorten with hash
SHA1Reset(&sha1);
SHA1Input(&sha1, (const unsigned char *)secret, len);
SHA1Result(&sha1);
get_hash(&sha1, key);
} else {
memcpy(key, secret, len);
}
//XOR key with IPAD
for (i=0; i<BLOCKSIZE; i++) {
key[i] ^= IPAD;
}
//First SHA hash
SHA1Reset(&sha1);
SHA1Input(&sha1, (const unsigned char *)key, BLOCKSIZE);
SHA1Input(&sha1, (const unsigned char *)msg, strlen(msg));
SHA1Result(&sha1);
get_hash(&sha1, hash);
//XOR key with OPAD
for (i=0; i<BLOCKSIZE; i++) {
key[i] ^= IPAD ^ OPAD;
}
//Second hash
SHA1Reset(&sha2);
SHA1Input(&sha2, (const unsigned char *)key, BLOCKSIZE);
SHA1Input(&sha2, (const unsigned char *)hash, SHA1_LEN);
SHA1Result(&sha2);
char s[SHA1_STR_LEN];
for(i = 0; i < 5 ; i++) {
sprintf(s+i*8,"%.8x", sha2.Message_Digest[i]);
}
lua_pushlstring(L,s,SHA1_STR_LEN);
return 1;
}
static char *
jingle_get_hmac_sha1(const char *key, int keylen, char *data, int datalen)
{
unsigned char k_ipad[65];
unsigned char k_opad[65];
SHA1Context sha;
SHA1Context sha2;
int i;
uint8_t Message_Digest[20];
uint8_t *Message_Digest2;
md5_state_t state;
md5_byte_t digest[16];
md5_byte_t *__key = (md5_byte_t *) key;
int __keylen = keylen;
x_memset(digest, 0, 16);
if (__keylen > 64)
{
md5_init(&state);
md5_append(&state, (const md5_byte_t *) __key, __keylen);
md5_finish(&state, digest);
__key = digest;
__keylen = 16;
}
x_memset(k_ipad, 0, sizeof(k_ipad));
x_memset(k_opad, 0, sizeof(k_opad));
x_memcpy(k_ipad, __key, __keylen);
x_memcpy(k_opad, __key, __keylen);
/* XOR key with ipad and opad values */
for (i = 0; i < 64; i++)
{
k_ipad[i] ^= IPAD;
k_opad[i] ^= OPAD;
}
SHA1Reset(&sha);
SHA1Input(&sha, (const uint8_t *) k_ipad, 64);
SHA1Input(&sha, (const uint8_t *) data, datalen);
SHA1Result(&sha, Message_Digest);
Message_Digest2 = x_malloc(20);
SHA1Reset(&sha2);
SHA1Input(&sha2, (const uint8_t *) k_opad, 64);
SHA1Input(&sha2, (const uint8_t *) Message_Digest, 20);
SHA1Result(&sha2, Message_Digest2);
// TRACE("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&\n");
//TRACE("HMAC-SHA1: ");
// hexdump((char *)Message_Digest2,20);
//TRACE("\n");
return (char *) Message_Digest2;
}
void
BCMROMFN(hmac_sha1)(unsigned char *text, int text_len, unsigned char *key,
int key_len, unsigned char *digest)
{
SHA1Context icontext, ocontext;
uint32 pki[(PRF_MAX_KEY_LEN / sizeof(uint32)) + 1];
uint32 pko[(PRF_MAX_KEY_LEN / sizeof(uint32)) + 1];
uint8 *k_ipad = (uint8 *)pki;
uint8 *k_opad = (uint8 *)pko;
int i;
/* if key is longer than 64 bytes reset it to key = SHA1(key) */
if (key_len > 64) {
SHA1Context tctx;
SHA1Reset(&tctx);
SHA1Input(&tctx, key, key_len);
SHA1Result(&tctx, key);
key_len = 20;
}
/*
* the HMAC_SHA1 transform looks like:
*
* SHA1(K XOR opad, SHA1(K XOR ipad, text))
*
* where K is an n byte key
* ipad is the byte 0x36 repeated 64 times
* opad is the byte 0x5c repeated 64 times
* and text is the data being protected
*/
/* start out by storing key in pads */
memcpy(k_ipad, key, key_len);
memset(&k_ipad[key_len], 0, PRF_MAX_KEY_LEN + 1 - key_len);
memcpy(k_opad, k_ipad, PRF_MAX_KEY_LEN + 1);
/* XOR key with ipad and opad values */
for (i = 0; i < 16; i++) {
pki[i] ^= 0x36363636;
pko[i] ^= 0x5c5c5c5c;
}
/* init contexts */
SHA1Reset(&icontext);
memcpy(&ocontext, &icontext, sizeof(icontext));
/* perform inner SHA1 */
SHA1Input(&icontext, k_ipad, 64); /* start with inner pad */
SHA1Input(&icontext, text, text_len); /* then text of datagram */
SHA1Result(&icontext, digest); /* finish up 1st pass */
/* perform outer SHA1 */
SHA1Input(&ocontext, k_opad, 64); /* start with outer pad */
SHA1Input(&ocontext, digest, 20); /* then results of 1st hash */
SHA1Result(&ocontext, digest); /* finish up 2nd pass */
}
void iWA_Crypto_TestSHA1(void)
{
iWAuint8 s[32] =
{
0x98, 0x79, 0x0A, 0x0C, 0x01, 0x51, 0xE9, 0xD7,
0xBD, 0x04, 0xC4, 0x3B, 0xC8, 0xBD, 0xC0, 0xD4,
0xD7, 0x06, 0x76, 0x12, 0x9C, 0x0B, 0x56, 0x56,
0x21, 0xEA, 0x40, 0x7D, 0x10, 0xFF, 0xE7, 0xA5
};
iWAuint8 p[20] =
{
0x0C, 0x4B, 0x05, 0xE6, 0x9D, 0x9A, 0x17, 0xDD,
0x38, 0xB5, 0x2A, 0x94, 0x42, 0xD7, 0x69, 0xE8,
0x5C, 0xB2, 0x32, 0xCA
};
iWAint32 ret;
static SHA1Context ctx;
static iWAuint8 digest[SHA1HashSize];
ret = SHA1Reset(&ctx);
ret = SHA1Input(&ctx, "LOUHAO:LOUHAO", 13);
ret = SHA1Result(&ctx, digest); // digest should be CA32B25CE869D742942AB538DD179A9DE6054B0C
{
int a,b;
iWAuint8 c;
for(a=0,b=31;a<16;a++,b--)
{
c = s[a];
s[a] = s[b];
s[b] = c;
}
for(a=0,b=19;a<10;a++,b--)
{
c = p[a];
p[a] = p[b];
p[b] = c;
}
}
ret = SHA1Reset(&ctx);
ret = SHA1Input(&ctx, s, 32);
ret = SHA1Input(&ctx, p, 20);
ret = SHA1Result(&ctx, digest); //digest should be 45DC3D9EDAD2D18DDBDC97ED7FAD827CEC84725E
return;
}
void hmac_sha1(const char* pBlob,
size_t nBlob,
const char* pKey,
size_t nKey,
char* digest)
{
SHA1Context context ;
char cTempKey[20] ;
char iPad[64] ;
char oPad[64] ;
int i ;
// If the key length is larger then 64 bytes, replace with hash of the key
if (nKey > 64)
{
SHA1Reset(&context) ;
SHA1Input(&context, pKey, nKey) ;
memset(cTempKey, 0, sizeof(cTempKey)) ;
SHA1Result(&context, cTempKey) ;
pKey = cTempKey ;
nKey = 20 ;
}
// Initialize opad and ipad
memset(iPad, 0, 64) ;
memset(oPad, 0, 64) ;
if (pKey)
{
memcpy(iPad, pKey, nKey) ;
memcpy(oPad, pKey, nKey) ;
}
for (i=0; i<64; i++)
{
iPad[i] ^= 0x36 ;
oPad[i] ^= 0x5c ;
}
// Step one using iPad
SHA1Reset(&context) ;
SHA1Input(&context, iPad, 64) ;
SHA1Input(&context, pBlob, nBlob) ;
SHA1Result(&context, digest) ;
// Step two using oPad
SHA1Reset(&context) ;
SHA1Input(&context, oPad, 64) ;
SHA1Input(&context, digest, 20) ;
SHA1Result(&context, digest) ;
}
key_t
bb_utils_ntok_user(const char* name, int32_t user_specific) {
key_t s_key;
int32_t retcode;
SHA1Context sha;
uint8_t Message_Digest[20];
/* We use the first byte of a SHA1 hash of the BBname
* unless the algorithm fail.
* If SHA1 fail we go back to poor key generation method
* using the name length.
* In both case we must Xored the key with user_specific in order
* to isolate different user from using the same key
*/
retcode = SHA1Reset(&sha);
retcode &= SHA1Input(&sha, (const unsigned char *) name,strlen(name));
retcode &= SHA1Result(&sha, Message_Digest);
/* SHA 1 NOK back to old poor method */
if (0 != retcode) {
s_key = ((strlen(name) << 16) & 0xFFFF0000) ^ (user_specific & 0x0000FFFF);
} else {
s_key = (Message_Digest[0] |
(Message_Digest[1] << 8) |
(Message_Digest[2] << 16)|
(Message_Digest[3] << 24)) ^
user_specific;
}
return s_key;
} /* end of bb_utils_ntok_user */
void GetHashStr(wchar_t *Password, char *HashStr)
{
HashStr[0]='\0';
SHA1Context sha;
SHA1Reset(&sha);
SHA1Input(&sha, (const unsigned char *) Password, (DWORD)(wcslen(Password)+1)*2);
if (SHA1Result(&sha)) {
// Crea la stringa per la comparazione
unsigned char *ptr = (unsigned char *)sha.Message_Digest;
char TmpBuf[128];
unsigned char tail=0;
// Calcolo Tail
for(int i=0; i<20; i++) {
unsigned char c = ptr[i];
tail += c;
}
for(int i=0; i<5; i++) {
wsprintf(TmpBuf,"%s%.8X", HashStr, sha.Message_Digest[i]);
strcpy_s(HashStr, 1024, TmpBuf);
}
// Aggiunge gli ultimi 2 byte
wsprintf(TmpBuf, "%s%2.2X", HashStr, tail);
strcpy_s(HashStr, 1024, TmpBuf);
}
}
void calc_accept_key(char* s, char* r)
{
const char* magicKey="258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
char sInput[64]={0x00,};
char tmpBuf[32]={0x00,};
strcpy(sInput,s);
strcpy(sInput+strlen(s),magicKey);
printf("input: %s\r\n",sInput);
SHA1Context sha;
SHA1Reset(&sha);
SHA1Input(&sha, (const unsigned char *)sInput, strlen(sInput));
if (!SHA1Result(&sha)){
printf("ERROR-- could not compute message digest\n");
}else{
for(unsigned char i = 0; i < 5 ; i++){
tmpBuf[i*4+0]=*((char*)&sha.Message_Digest[i]+3);
tmpBuf[i*4+1]=*((char*)&sha.Message_Digest[i]+2);
tmpBuf[i*4+2]=*((char*)&sha.Message_Digest[i]+1);
tmpBuf[i*4+3]=*((char*)&sha.Message_Digest[i]+0);
}
for(unsigned char i=0;i<20;i++)
printf("%02X", tmpBuf[i]);
printf("\r\n");
base64encode(tmpBuf,r,20);
}
}
void sha1_mac(char *key, size_t key_size, char *message, size_t message_size, char *mac) {
SHA1Context ctx;
assert(shaSuccess == SHA1Reset(&ctx));
assert(shaSuccess == SHA1Input(&ctx, (uint8_t *)key, key_size));
assert(shaSuccess == SHA1Input(&ctx, (uint8_t *)message, message_size));
assert(shaSuccess == SHA1Result(&ctx, (uint8_t *)mac));
}
int main(int argc , char *argv[])
{
SHA1Context sha;
int i;
char sha1hash[70];
int num =2;
char ulstring[70];
sha1hash[0]='\0';
char command[100];
SHA1Reset(&sha);
SHA1Input(&sha, (const unsigned char *) argv[1], strlen(argv[1]));
if (!SHA1Result(&sha))
{
fprintf(stderr, "ERROR-- could not compute message digest\n");
}
else
{
printf("\t");
for(i = 0; i < 5 ; i++)
{
sprintf(ulstring,"%X", sha.Message_Digest[i]);
strcat(sha1hash,ulstring);
}
}
printf("\n");
printf("\t%s\n",sha1hash);
return 0;
}
int
SHA1Compute (const unsigned char *message_array, unsigned length, SHA1Hash * hash)
{
SHA1Context context;
assert (message_array != NULL);
assert (hash != NULL);
SHA1Reset (&context);
SHA1Input (&context, message_array, length);
if (!SHA1Result (&context))
{
assert (false);
/* TODO: Set an appropiate error message. */
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_GENERIC_ERROR, 0);
return ER_FAILED;
}
hash->h[0] = (INT32) context.Message_Digest[0];
hash->h[1] = (INT32) context.Message_Digest[1];
hash->h[2] = (INT32) context.Message_Digest[2];
hash->h[3] = (INT32) context.Message_Digest[3];
hash->h[4] = (INT32) context.Message_Digest[4];
return NO_ERROR;
}
char *
clicon_sha1hex(const char *str)
{
int i;
char *retstr;
SHA1Context context;
SHA1Reset(&context);
SHA1Input(&context, (const unsigned char *)str, strlen(str));
if (!SHA1Result(&context)) {
clicon_err(OE_UNIX, 0, "Could not compute SHA1 message digest");
return NULL;
}
/* 160 bits = 20 bytes = 40 hexdigits + '\0' */
if ((retstr = malloc(41)) == NULL) {
clicon_err(OE_UNIX, errno, "malloc");
return NULL;
}
for(i = 0; i < 5 ; i++)
sprintf(retstr + (i*8), "%.8x", context.Message_Digest[i]);
return retstr;
}
void main()
{
char i;
idata SHA1Context sha;
store_cpu_rate(16);
P0_DIR &= ~0x28;
P0_ALT &= ~0x28;
serial_init(19200);
for(i=0;i<6;i++)
{
blink_led();
mdelay(400);
}
sha_counter++;
while(1)
{
SHA1Reset(&sha);
SHA1Input(&sha, (const unsigned char *) TESTA, 3);
SHA1Result(&sha);
sha_counter++;
//blink_led();
int_print(sha_counter);
puts("\r\n");
}
}
static int get_sha1(const char *path, char *result)
{
int fd;
int rv;
unsigned char buff[4096];
SHA1Context sha;
fd = open(path, O_RDONLY);
if (fd < 0) {
return -errno;
}
SHA1Reset(&sha);
rv = 1;
while (rv > 0) {
rv = read(fd, buff, 4096);
if (rv < 0) {
close(fd);
return -errno;
}
SHA1Input(&sha, buff, rv);
}
if (!SHA1Result(&sha)) {
return -1;
}
sprintf(result, "%08X%08X%08X%08X%08X",
sha.Message_Digest[0],
sha.Message_Digest[1],
sha.Message_Digest[2],
sha.Message_Digest[3], sha.Message_Digest[4]);
return 0;
}
const char * generate_websocket_resp(const char * req, size_t reqlen, char * dest, size_t destlen)
{
/* char origin[256]; */
/* char protocol[256]; */
/* char key1[256]; */
/* char key2[256]; */
char key[256];
char upgrade[64];
/* get_header_value(req, reqlen, "Origin", origin, sizeof(origin)); */
/* get_header_value(req, reqlen, "Sec-WebSocket-Protocol", protocol, sizeof(protocol)); */
get_header_value(req, reqlen, "Upgrade", upgrade, sizeof(upgrade));
/* get_header_value(req, reqlen, "Sec-WebSocket-Key1", key1, sizeof(key1)); */
/* get_header_value(req, reqlen, "Sec-WebSocket-Key2", key2, sizeof(key2)); */
get_header_value(req, reqlen, "Sec-WebSocket-Key", key, sizeof(key));
if (key[0] != '\0') {
char key_sha1[128];
char key_base64[128];
SHA1Context sha;
strcat(key, "258EAFA5-E914-47DA-95CA-C5AB0DC85B11");
SHA1Reset(&sha);
SHA1Input(&sha, ( const unsigned char * )key, strlen(key));
SHA1Result(&sha);
memset(key_sha1, 0, sizeof(key_sha1));
memset(key_base64, 0, sizeof(key_base64));
int i, j;
for (i = 0; i < 5; i++) {
for (j = 0; j < 4; j++) {
key_sha1[i*4+j] = sha.Message_Digest[i] << (8*j) >> 24;
}
}
base64_encode(key_sha1, strlen(key_sha1), key_base64, sizeof(key_base64));
snprintf(dest, destlen, "HTTP/1.1 101 Switching Protocols\r\nUpgrade: %s\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: %s\r\n\r\n", upgrade, key_base64);
return dest;
}
/**********************************************
SumComputeBuff(): Compute the checksum, allocate and
return a string containing the sum value.
NOTE: The calling function must free() the string!
Returns NULL on error.
**********************************************/
Cksum * SumComputeBuff (CksumFile *CF)
{
int rc;
SHA1Context sha1;
MyMD5_CTX md5;
Cksum *Sum;
Sum = (Cksum *)calloc(1,sizeof(Cksum));
if (!Sum) return(NULL);
Sum->DataLen = CF->MmapSize;
MyMD5_Init(&md5);
rc = SHA1Reset(&sha1);
if (rc)
{
fprintf(stderr,"ERROR: Unable to initialize sha1\n");
free(Sum);
return(NULL);
}
MyMD5_Update(&md5,CF->Mmap,CF->MmapSize);
MyMD5_Final(Sum->MD5digest,&md5);
SHA1Input(&sha1,CF->Mmap,CF->MmapSize);
rc = SHA1Result(&sha1,Sum->SHA1digest);
if (rc)
{
fprintf(stderr,"ERROR: Failed to compute sha1\n");
free(Sum);
return(NULL);
}
return(Sum);
} /* SumComputeBuff() */
int sr_handle_auth_request(struct sr_instance* sr, c_auth_request* req) {
#define AUTH_KEY_LEN 64
#define SHA1_LEN 20
char auth_key[AUTH_KEY_LEN+1];
FILE* fp;
SHA1Context sha1;
c_auth_reply* ar;
char* buf;
int len, len_username, i, ret;
/* read in the user's auth key */
fp = fopen(sr->auth_key_fn, "r");
if(fp) {
if(fgets(auth_key, AUTH_KEY_LEN+1, fp) != auth_key) {
fclose(fp);
return 0;
}
fclose(fp);
/* compute the salted SHA1 of password from auth_key */
SHA1Reset(&sha1);
SHA1Input(&sha1, req->salt, ntohl(req->mLen) - sizeof(*req));
SHA1Input(&sha1, (unsigned char*)auth_key, AUTH_KEY_LEN);
if(!SHA1Result(&sha1)) {
fprintf(stderr, "SHA1 result could not be computed\n");
return 0;
}
/* build the auth reply packet and then send it */
len_username = strlen(sr->user);
len = sizeof(c_auth_reply) + len_username + SHA1_LEN;
buf = (char*)malloc(len);
if(!buf) {
perror("malloc failed");
return 0;
}
ar = (c_auth_reply*)buf;
ar->mLen = htonl(len);
ar->mType = htonl(VNS_AUTH_REPLY);
ar->usernameLen = htonl(len_username);
strcpy(ar->username, sr->user);
for(i=0; i<5; i++)
sha1.Message_Digest[i] = htonl(sha1.Message_Digest[i]);
memcpy(ar->username + len_username, sha1.Message_Digest, SHA1_LEN);
if(send(sr->sockfd, buf, len, 0) != len) {
perror("send(..):sr_client.c::sr_handle_auth_request()");
ret = 0;
}
else
ret = 1;
free(buf);
return ret;
}
else {
perror("unable to read credentials from authentication key file");
return 0; /* failed */
}
}
void check_password()
{
SHA1Context sha;
char pass_sha1[20];
if (password_str_len <= 0)
{
if (restricted_screen_mode != RESTRICTED_SCREEN_FILTER_OPTION)
filter_option_to_set = FILTER_OPTION_TO_SET_NONE;
restricted_screen_mode = RESTRICTED_SCREEN_CHECK_PASSWORD;
enter_password_screen(get_nls_text("enter_password"));
}
else
{
SHA1Reset(&sha);
SHA1Input(&sha, (const unsigned char *) password_string, password_str_len);
SHA1Result(&sha);
memcpy(pass_sha1, sha.Message_Digest, 20);
if (memcmp(pass_sha1, restriction_pass1, 20))
{
password_str_len = 0;
if (restricted_screen_mode != RESTRICTED_SCREEN_CHANGE_PASSWORD)
restricted_screen_mode = RESTRICTED_SCREEN_CHECK_PASSWORD;
enter_password_screen(get_nls_text("try_again"));
}
else
{
if (restricted_screen_mode == RESTRICTED_SCREEN_CHANGE_PASSWORD)
{
password_str_len = 0;
keyboard_set_mode(KEYBOARD_PASSWORD_CHAR);
enter_password_screen(get_nls_text("enter_new_password"));
restricted_screen_mode = RESTRICTED_SCREEN_SET_PASSWORD;
}
else if (filter_option_to_set == FILTER_OPTION_TO_SET_ON)
{
restriction_filter_off = 0;
save_password(1);
last_display_mode = DISPLAY_MODE_ARTICLE;
display_mode = DISPLAY_MODE_ARTICLE;
display_retrieved_article(saved_idx_article);
}
else if (filter_option_to_set == FILTER_OPTION_TO_SET_OFF)
{
restriction_filter_off = 1;
save_password(2);
last_display_mode = DISPLAY_MODE_ARTICLE;
display_mode = DISPLAY_MODE_ARTICLE;
display_retrieved_article(saved_idx_article);
}
else
{
display_mode = DISPLAY_MODE_ARTICLE;
display_retrieved_article(saved_idx_article);
}
}
}
}
/**
* Generate new token for given version string.
*/
static char *
tok_generate(time_t now, const char *version)
{
char token[TOKEN_BASE64_SIZE + 1];
char digest[TOKEN_VERSION_SIZE];
char lvldigest[LEVEL_SIZE];
char lvlbase64[LEVEL_BASE64_SIZE + 1];
const struct tokkey *tk;
uint32 crc32;
uint idx;
const char *key;
SHA1Context ctx;
struct sha1 sha1;
int lvlsize;
int i;
/*
* Compute token.
*/
key = random_key(now, &idx, &tk);
now = clock_loc2gmt(now); /* As close to GMT as possible */
poke_be32(&digest[0], now);
random_bytes(&digest[4], 3);
digest[6] &= 0xe0U; /* Upper 3 bits only */
digest[6] |= idx & 0xffU; /* Has 5 bits for the index */
SHA1Reset(&ctx);
SHA1Input(&ctx, key, strlen(key));
SHA1Input(&ctx, digest, 7);
SHA1Input(&ctx, version, strlen(version));
SHA1Result(&ctx, &sha1);
memcpy(&digest[7], sha1.data, SHA1_RAW_SIZE);
/*
* Compute level.
*/
lvlsize = G_N_ELEMENTS(token_keys) - (tk - token_keys);
crc32 = crc32_update(0, digest, TOKEN_VERSION_SIZE);
for (i = 0; i < lvlsize; i++) {
poke_be16(&lvldigest[i*2], tok_crc(crc32, tk));
tk++;
}
/*
* Encode into base64.
*/
base64_encode_into(digest, TOKEN_VERSION_SIZE, token, TOKEN_BASE64_SIZE);
token[TOKEN_BASE64_SIZE] = '\0';
ZERO(&lvlbase64);
base64_encode_into(lvldigest, 2 * lvlsize, lvlbase64, LEVEL_BASE64_SIZE);
return g_strconcat(token, "; ", lvlbase64, (void *) 0);
}
static int
verify_sha1_final(void)
{
int ret;
ret = SHA1Result(&verify_sha1.context, &verify_sha1.digest);
return shaSuccess == ret ? 0 : -1;
}
int hash_sha1(const uint8_t* data, unsigned int bytes, uint8_t sha1[20])
{
SHA1Context ctx;
SHA1Reset(&ctx);
SHA1Input(&ctx, data, bytes);
SHA1Result(&ctx, sha1);
return 0;
}
/**
* Calculates the CD-Key hash for use in SID_AUTH_CHECK (0x51)
* Returns the length of the generated hash; call getHash and pass
* it a character array that is at least this size. Returns 0 on failure.
*
* Note that clientToken and serverToken will be added to the buffer and
* hashed as-is, regardless of system endianness. It is assumed that
* the program's extraction of the server token does not change its
* endianness, and since the client token is generated by the client,
* endianness is not a factor.
*/
size_t CDKeyDecoder::calculateHash(uint32_t clientToken,
uint32_t serverToken)
{
struct CDKEYHASH kh;
SHA1Context sha;
if (!initialized || !keyOK) return 0;
hashLen = 0;
kh.clientToken = clientToken;
kh.serverToken = serverToken;
switch (keyType) {
case KEY_STARCRAFT:
case KEY_WARCRAFT2:
kh.product = (uint32_t) LSB4(product);
kh.value1 = (uint32_t) LSB4(value1);
kh.value2.s.zero = 0;
kh.value2.s.v = (uint32_t) LSB4(value2);
keyHash = new char[20];
calcHashBuf((char*) &kh, 24, keyHash);
hashLen = 20;
#if DEBUG
bncsutil_debug_message_a("%s: Hash calculated.", cdkey);
bncsutil_debug_dump(keyHash, 20);
#endif
return 20;
case KEY_WARCRAFT3:
kh.product = (uint32_t) MSB4(product);
kh.value1 = (uint32_t) MSB4(value1);
memcpy(kh.value2.l.v, w3value2, 10);
if (SHA1Reset(&sha))
return 0;
if (SHA1Input(&sha, (const unsigned char*) &kh, 26))
return 0;
keyHash = new char[20];
if (SHA1Result(&sha, (unsigned char*) keyHash)) {
SHA1Reset(&sha);
return 0;
}
SHA1Reset(&sha);
hashLen = 20;
#if DEBUG
bncsutil_debug_message_a("%s: Hash calculated.", cdkey);
bncsutil_debug_dump(keyHash, 20);
#endif
return 20;
default:
return 0;
}
}
static int sttSaveAvatar()
{
FILE* in;
SHA1Context sha;
// MD5Context md5;
unsigned char buf[ 512 ];
char tFileName[ MAX_PATH ];
int i, pictureType;
int bIsFirst = 1;
struct _stat statbuf;
uint8_t digest[20];
if (_stat(szFileName, &statbuf)) return 1;
if (statbuf.st_size > 6 * 1024) return 1;
TlenGetAvatarFileName( NULL, tFileName, sizeof tFileName );
if ( CopyFileA( szFileName, tFileName, FALSE ) == FALSE ) {
JabberLog( "Copy failed with error %d", GetLastError() );
return 1;
}
SHA1Reset(&sha);
// md5_init(&md5);
in = fopen( tFileName, "rb" );
if ( in == NULL )
return 1;
while( !feof( in )) {
int bytes = fread( buf, 1, sizeof buf, in );
if ( bIsFirst ) {
pictureType = JabberGetPictureType( buf );
bIsFirst = 0;
}
SHA1Input(&sha, buf, bytes);
// md5_update(&md5, buf, bytes);
}
fclose( in );
if ( pictureType == PA_FORMAT_UNKNOWN )
return 1;
SHA1Result(&sha, digest);
// md5_finalize(&md5);
for (i=0;i<20;i++) {
// unsigned int val = (md5.state[i>>2] >> 8*(i%4)) & 0xFF;
sprintf( buf+( i<<1 ), "%02x", digest[i]);
}
DBWriteContactSettingString(NULL, jabberProtoName, "AvatarHash", buf);
DBWriteContactSettingDword(NULL, jabberProtoName, "AvatarFormat", pictureType);
if (userAvatarHash != NULL) {
free (userAvatarHash);
userAvatarHash = NULL;
}
userAvatarHash = strdup(buf);
userAvatarFormat = pictureType;
TlenGetAvatarFileName(NULL, szFileName, MAX_PATH);
if ( strcmp( szFileName, tFileName ))
MoveFileA( tFileName, szFileName );
return 0;
}
MEXP(void) nls_get_K(nls_t* nls, char* out, const char* S) {
char odd[16], even[16];
uint8_t odd_hash[20], even_hash[20];
char* Sp = (char*) S;
char* op = odd;
char* ep = even;
unsigned int i;
SHA1Context ctx;
if (!nls)
return;
if (nls->K) {
memcpy(out, nls->K, 40);
return;
}
for (i = 0; i < 16; i++) {
*(op++) = *(Sp++);
*(ep++) = *(Sp++);
}
SHA1Reset(&ctx);
SHA1Input(&ctx, (uint8_t*) odd, 16);
SHA1Result(&ctx, odd_hash);
SHA1Reset(&ctx);
SHA1Input(&ctx, (uint8_t*) even, 16);
SHA1Result(&ctx, even_hash);
Sp = out;
op = (char*) odd_hash;
ep = (char*) even_hash;
for (i = 0; i < 20; i++) {
*(Sp++) = *(op++);
*(Sp++) = *(ep++);
}
nls->K = (char*) malloc(40);
if (nls->K)
memcpy(nls->K, out, 40);
}
// Private non-vararg version of sha1
// Accepts size and an array of bytes.
// Returns a pointer to a 20-byte hash.
uint8_t* _sha1(int size, uint8_t* buffer) {
SHA1Context context;
SHA1Reset(&context);
SHA1Input(&context, buffer, size);
uint8_t* hash = malloc(20 * sizeof(uint8_t));
if( SHA1Result(&context, hash) != shaSuccess ) { return NULL; }
return hash;
}
