static void srp_get_x(srp_t *srp, mpz_t x_c, const gchar *raw_salt)
{
gchar *userpass;
guint8 hash[SHA1_HASH_SIZE], final_hash[SHA1_HASH_SIZE];
sha1_context ctx;
ctx.version = SHA1_TYPE_NORMAL;
// build the string Username:Password
userpass = (gchar *) g_malloc(srp->username_len + srp->password_len + 2);
memcpy(userpass, srp->username_upper, srp->username_len);
userpass[srp->username_len] = ':';
memcpy(userpass + srp->username_len + 1, srp->password_upper, srp->password_len);
userpass[srp->username_len + srp->password_len + 1] = 0; // null-terminator
// get the SHA-1 hash of the string
sha1_reset(&ctx);
sha1_input(&ctx, (guint8 *) userpass,
(srp->username_len + srp->password_len + 1));
sha1_digest(&ctx, hash);
g_free(userpass);
// get the SHA-1 hash of the salt and user:pass hash
sha1_reset(&ctx);
sha1_input(&ctx, (guint8 *) raw_salt, 32);
sha1_input(&ctx, hash, 20);
sha1_digest(&ctx, final_hash);
// 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, (gchar *) final_hash);
}
void srp_get_M1(srp_t *srp, gchar *out, const gchar *B, const gchar *salt)
{
sha1_context ctx;
guint8 username_hash[SHA1_HASH_SIZE];
gchar A[32];
gchar S[32];
gchar K[40];
ctx.version = SHA1_TYPE_NORMAL;
if (!srp)
return;
if (srp->M1) {
purple_debug_info("bnet", "SRP: srp_get_M1() using cached M[1] value.");
memcpy(out, srp->M1, 20);
return;
}
/* calculate SHA-1 hash of username */
sha1_reset(&ctx);
sha1_input(&ctx, (guint8 *) srp->username_upper, srp->username_len);
sha1_digest(&ctx, username_hash);
srp_get_A(srp, A);
srp_get_S(srp, S, B, salt);
srp_get_K(srp, K, S);
/* calculate M[1] */
sha1_reset(&ctx);
sha1_input(&ctx, (guint8 *) srp_I, 20);
sha1_input(&ctx, username_hash, 20);
sha1_input(&ctx, (guint8 *) salt, 32);
sha1_input(&ctx, (guint8 *) A, 32);
sha1_input(&ctx, (guint8 *) B, 32);
sha1_input(&ctx, (guint8 *) K, 40);
sha1_digest(&ctx, (guint8 *) out);
srp->salt = (gchar *) g_malloc(32);
srp->B = (gchar *) g_malloc(32);
srp->M1 = (gchar *) g_malloc(20);
if (srp->salt)
g_memmove(srp->salt, salt, 32);
if (srp->B)
g_memmove(srp->B, B, 32);
if (srp->M1)
g_memmove(srp->M1, out, 20);
}
int
_mesa_sha1_final(struct mesa_sha1 *ctx, unsigned char result[20])
{
sha1_digest((struct sha1_ctx *) ctx, 20, result);
free(ctx);
return 1;
}
void
rsa_sign_msg(struct rsa_private_key *priv,mpz_t s, uint8_t *msg, const size_t len)
{
uint8_t digest[SHA1_DIGEST_SIZE];
struct sha1_ctx sha1ctx;
int i = 0,nloop = 0;
if(priv == NULL || msg == NULL || len == 0) {
die("priv == NULL || msg == NULL || len == 0");
}
//printf("\nMSG_LEN: %d\n",len);
bzero(&sha1ctx,sizeof(struct sha1_ctx));
bzero(&digest[0],SHA1_DIGEST_SIZE);
mpz_init(s);
sha1_init(&sha1ctx);
sha1_update(&sha1ctx,len,msg);
sha1_digest(&sha1ctx,SHA1_DIGEST_SIZE,digest);
if (!rsa_sha1_sign_digest(priv, digest, s)) {
// out("rsa_sha1_sign...try again\n");
rsa_sign_msg(priv,s,msg,len);
}
}
/*
* Calculates SHA-1 hash of *src*. The size of *src* is *src_length* bytes.
* *dst* must be at least SHA1_DIGEST_SIZE.
*/
void sha1(uint8_t *dst, const uint8_t *src, size_t src_length)
{
struct sha1_ctx ctx;
sha1_init(&ctx);
sha1_update(&ctx, src_length, src);
sha1_digest(&ctx, SHA1_DIGEST_SIZE, dst);
}
void srp_get_K(srp_t *srp, gchar *out, const gchar *S)
{
gchar odd[16], even[16];
guint8 odd_hash[SHA1_HASH_SIZE], even_hash[SHA1_HASH_SIZE];
gchar *Sp = (gchar *) S;
gchar *op = odd;
gchar *ep = even;
guint16 i;
sha1_context ctx;
ctx.version = SHA1_TYPE_NORMAL;
if (!srp)
return;
if (srp->K) {
g_memmove(out, srp->K, 40);
return;
}
for (i = 0; i < 16; i++) {
*(op++) = *(Sp++);
*(ep++) = *(Sp++);
}
sha1_reset(&ctx);
sha1_input(&ctx, (guint8 *) odd, 16);
sha1_digest(&ctx, odd_hash);
sha1_reset(&ctx);
sha1_input(&ctx, (guint8 *) even, 16);
sha1_digest(&ctx, even_hash);
Sp = out;
op = (gchar *) odd_hash;
ep = (gchar *) even_hash;
for (i = 0; i < 20; i++) {
*(Sp++) = *(op++);
*(Sp++) = *(ep++);
}
srp->K = (gchar *) g_malloc(40);
if (srp->K)
g_memmove(srp->K, out, 40);
}
void mediv_random_update(mediv_random_context *ctx){
sha1_context sha;
sha.version = SHA1;
sha1_reset(&sha);
sha1_input(&sha, ctx->source1, 0x14);
sha1_input(&sha, ctx->data, 0x14);
sha1_input(&sha, ctx->source2, 0x14);
sha1_digest(&sha, ctx->data);
}
unsigned char *createKey(msg_type logType, char *authKey) {
int size = strlen(intToStr(logType)) + strlen(authKey) + 1;
char *tmp = (char *)malloc(size);
memset(tmp,0,size);
strcpy(tmp, intToStr(logType));
strcat(tmp, authKey);
return sha1_digest(tmp);
}
std::string sha1(const std::string& src)
{
sha1_ctx ctx;
sha1_init(&ctx);
sha1_update(&ctx, src.size(), reinterpret_cast<const uint8_t*>(src.c_str()));
uint8_t temp[SHA1_DIGEST_SIZE];
sha1_digest(&ctx, SHA1_DIGEST_SIZE, temp);
std::string res(&temp[0], &temp[SHA1_DIGEST_SIZE]);
return res;
}
int
dsa_sha1_verify(const struct dsa_public_key *key,
struct sha1_ctx *hash,
const struct dsa_signature *signature)
{
uint8_t digest[SHA1_DIGEST_SIZE];
sha1_digest(hash, sizeof(digest), digest);
return _dsa_verify(key, sizeof(digest), digest, signature);
}
static void
do_sha_digest(struct hash_instance *s,
UINT8 *dst)
{
CAST(sha_instance, self, s);
sha1_final(&self->ctx);
sha1_digest(&self->ctx, SHA1_DIGEST_SIZE, dst);
sha1_init(&self->ctx);
}
int
dsa_sha1_sign(const struct dsa_public_key *pub,
const struct dsa_private_key *key,
void *random_ctx, nettle_random_func *random,
struct sha1_ctx *hash,
struct dsa_signature *signature)
{
uint8_t digest[SHA1_DIGEST_SIZE];
sha1_digest(hash, sizeof(digest), digest);
return _dsa_sign(pub, key, random_ctx, random,
sizeof(digest), digest, signature);
}
static void
hash(mpz_t x, uint8_t *digest)
{
mpz_t t;
uint8_t data[SEED_LENGTH];
struct sha1_ctx ctx;
mpz_init_set(t, x);
mpz_fdiv_r_2exp(t, t, SEED_BITS);
nettle_mpz_get_str_256(SEED_LENGTH, data, t);
mpz_clear(t);
sha1_init(&ctx);
sha1_update(&ctx, SEED_LENGTH, data);
sha1_digest(&ctx, SHA1_DIGEST_SIZE, digest);
}
int
rsa_keypair_to_openpgp(struct nettle_buffer *buffer,
const struct rsa_public_key *pub,
const struct rsa_private_key *priv,
/* A single user id. NUL-terminated utf8. */
const char *userid)
{
time_t now = time(NULL);
unsigned key_start;
unsigned userid_start;
struct sha1_ctx key_hash;
struct sha1_ctx signature_hash;
uint8_t fingerprint[SHA1_DIGEST_SIZE];
key_start = buffer->size;
if (!pgp_put_public_rsa_key(buffer, pub, now))
return 0;
/* userid packet */
userid_start = buffer->size;
if (!pgp_put_userid(buffer, strlen(userid), userid))
return 0;
/* FIXME: We hash the key first, and then the user id. Is this right? */
sha1_init(&key_hash);
sha1_update(&key_hash,
userid_start - key_start,
buffer->contents + key_start);
signature_hash = key_hash;
sha1_digest(&key_hash, sizeof(fingerprint), fingerprint);
sha1_update(&signature_hash,
buffer->size - userid_start,
buffer->contents + userid_start);
return pgp_put_rsa_sha1_signature(buffer,
priv,
fingerprint + SHA1_DIGEST_SIZE - 8,
PGP_SIGN_CERTIFICATION,
&signature_hash);
}
int
pkcs1_rsa_sha1_encode(mpz_t m, unsigned size, struct sha1_ctx *hash)
{
TMP_DECL(em, uint8_t, NETTLE_MAX_BIGNUM_BITS / 8);
TMP_ALLOC(em, size);
if (pkcs1_signature_prefix(size, em,
sizeof(sha1_prefix),
sha1_prefix,
SHA1_DIGEST_SIZE))
{
sha1_digest(hash, SHA1_DIGEST_SIZE, em + size - SHA1_DIGEST_SIZE);
nettle_mpz_set_str_256_u(m, size, em);
return 1;
}
else
return 0;
}
static guint32 srp_get_u(const gchar *B)
{
sha1_context ctx;
union {
guint8 as8[SHA1_HASH_SIZE];
guint32 as32[5];
} data;
guint32 u;
ctx.version = SHA1_TYPE_NORMAL;
sha1_reset(&ctx);
sha1_input(&ctx, (guint8 *) B, 32);
sha1_digest(&ctx, data.as8);
u = data.as32[0];
u = MSB4(u); // needed? yes
return u;
}
static int
_digest_nettle(int algo, uint8_t* buf, size_t len,
unsigned char* res)
{
switch(algo) {
case SHA1_DIGEST_SIZE:
{
struct sha1_ctx ctx;
sha1_init(&ctx);
sha1_update(&ctx, len, buf);
sha1_digest(&ctx, SHA1_DIGEST_SIZE, res);
return 1;
}
case SHA256_DIGEST_SIZE:
{
struct sha256_ctx ctx;
sha256_init(&ctx);
sha256_update(&ctx, len, buf);
sha256_digest(&ctx, SHA256_DIGEST_SIZE, res);
return 1;
}
case SHA384_DIGEST_SIZE:
{
struct sha384_ctx ctx;
sha384_init(&ctx);
sha384_update(&ctx, len, buf);
sha384_digest(&ctx, SHA384_DIGEST_SIZE, res);
return 1;
}
case SHA512_DIGEST_SIZE:
{
struct sha512_ctx ctx;
sha512_init(&ctx);
sha512_update(&ctx, len, buf);
sha512_digest(&ctx, SHA512_DIGEST_SIZE, res);
return 1;
}
default:
break;
}
return 0;
}
int rsa_sha1_verify(rsa_public_key *key, sha1_ctx *hash, mpz_t signature)
{
int ret = -EBADMSG, id_idx;
uint8_t *prefix, *p;
mpz_t msg, expected;
mpz_init(msg);
/* add PKCS#1 prefix to hash, consists of 0x00, 0x01, 0xff ... 0xff, 0x00, id, hash */
prefix = malloc(key->size);
if(!prefix)
goto exit;
id_idx = key->size - SHA1_DIGEST_LENGTH - sizeof(rsa_pkcs1_sha1_prefix);
p = prefix;
*p++ = 0;
*p++ = 1;
memset(p, 0xff, id_idx - 3);
p += id_idx - 3;
*p++ = 0;
memcpy(p, rsa_pkcs1_sha1_prefix, sizeof(rsa_pkcs1_sha1_prefix));
p += sizeof(rsa_pkcs1_sha1_prefix);
sha1_digest(hash, p);
mpz_import(msg, key->size, 1, 1, 0, 0, prefix);
mpz_init(expected);
mpz_powm(expected, signature, key->e, key->n);
ret = mpz_cmp(msg, expected);
mpz_clear(expected);
exit:
mpz_clear(msg);
free(prefix);
return ret;
}
bool WSClientParser::GetHandShakeRespond(char** buffer, int& len) {
if( mState == WSClientState_Handshake ) {
mState = WSClientState_Data;
char input[256] = "";
unsigned char output[SHA1_HASH_SIZE] = "";
char b64[256] = "";
snprintf(input, sizeof(input), "%s%s", mWebSocketKey, WEBSOCKET_GUID);
sha1_digest(output, input);
b64encode((unsigned char *)output, SHA1_HASH_SIZE, (unsigned char *)b64, sizeof(b64));
char* temp = switch_core_sprintf(
mpPool,
"HTTP/1.1 101 Switching Protocols\r\n"
"Upgrade: websocket\r\n"
"Connection: Upgrade\r\n"
"Sec-WebSocket-Accept: %s\r\n"
"\r\n",
b64
);
*buffer = temp;
len = strlen(temp);
switch_log_printf(
SWITCH_CHANNEL_UUID_LOG(this->uuid),
SWITCH_LOG_INFO,
"WSClientParser::GetHandShakeRespond( "
"this : %p, "
"len : %d, "
"buffer : \n%s\n"
") \n",
this,
len,
*buffer
);
return true;
}
return false;
}
int
rsa_vrfy_msg(struct rsa_public_key *pub,mpz_t sign,const uint8_t *msg,const size_t len)
{
uint8_t digest[SHA1_DIGEST_SIZE];
struct sha1_ctx sha1ctx;
bzero(&sha1ctx,sizeof(struct sha1_ctx));
bzero(&digest[0],SHA1_DIGEST_SIZE);
sha1_init(&sha1ctx);
sha1_update(&sha1ctx,len,msg);
sha1_digest(&sha1ctx,SHA1_DIGEST_SIZE,digest);
//if (!rsa_sha1_verify(pub, &sha1ctx, sign)) {
if (!rsa_sha1_verify_digest(pub, &digest[0], sign)) {
return SIGN_INVALID;
}
return SIGN_VALID;
}
term_t cbif_sha_final1(proc_t *proc, term_t *regs)
{
term_t Context = regs[0];
if (!is_boxed_binary(Context))
badarg(Context);
bits_t bs, dst;
bits_get_real(peel_boxed(Context), &bs);
if (bs.ends -bs.starts != sizeof(struct sha1_ctx) *8)
badarg(Context);
struct sha1_ctx ctx;
bits_init_buf((uint8_t *)&ctx, sizeof(ctx), &dst);
bits_copy(&bs, &dst);
uint8_t *ptr;
term_t bin = heap_make_bin(&proc->hp, SHA1_DIGEST_SIZE, &ptr);
sha1_digest(&ctx, SHA1_DIGEST_SIZE, ptr);
return bin;
}
term_t cbif_sha1(proc_t *proc, term_t *regs)
{
term_t Data = regs[0];
if (!is_boxed_binary(Data) && !is_list(Data))
badarg(Data);
int sz = iolist_size(Data);
if (sz < 0)
badarg(Data);
assert(sz <= 65536); //TODO: use heap_tmp_buf for larger Data
uint8_t buf[sz];
iolist_flatten(Data, buf);
struct sha1_ctx ctx;
sha1_init(&ctx);
sha1_update(&ctx, sz, buf);
uint8_t *ptr;
term_t bin = heap_make_bin(&proc->hp, SHA1_DIGEST_SIZE, &ptr);
sha1_digest(&ctx, SHA1_DIGEST_SIZE, ptr);
return bin;
}
bool RarVolume::DecryptRar3Prepare(const uint8 salt[8])
{
WString wstr(*m_password);
int len = wstr.Length();
if (len == 0) return false;
CharBuffer seed(len * 2 + 8);
for (int i = 0; i < len; i++)
{
wchar_t ch = wstr[i];
seed[i * 2] = ch & 0xFF;
seed[i * 2 + 1] = (ch & 0xFF00) >> 8;
}
memcpy(seed + len * 2, salt, 8);
debug("seed: %s", *Util::FormatBuffer((const char*)seed, seed.Size()));
#ifdef HAVE_OPENSSL
EVP_MD_CTX* context = EVP_MD_CTX_create();
if (!EVP_DigestInit(context, EVP_sha1()))
{
EVP_MD_CTX_destroy(context);
return false;
}
#elif defined(HAVE_NETTLE)
sha1_ctx context;
sha1_init(&context);
#else
return false;
#endif
uint8 digest[20];
const int rounds = 0x40000;
for (int i = 0; i < rounds; i++)
{
#ifdef HAVE_OPENSSL
EVP_DigestUpdate(context, *seed, seed.Size());
#elif defined(HAVE_NETTLE)
sha1_update(&context, seed.Size(), (const uint8_t*)*seed);
#endif
uint8 buf[3];
buf[0] = (uint8)i;
buf[1] = (uint8)(i >> 8);
buf[2] = (uint8)(i >> 16);
#ifdef HAVE_OPENSSL
EVP_DigestUpdate(context, buf, sizeof(buf));
#elif defined(HAVE_NETTLE)
sha1_update(&context, sizeof(buf), buf);
#endif
if (i % (rounds / 16) == 0)
{
#ifdef HAVE_OPENSSL
EVP_MD_CTX* ivContext = EVP_MD_CTX_create();
EVP_MD_CTX_copy(ivContext, context);
EVP_DigestFinal(ivContext, digest, nullptr);
EVP_MD_CTX_destroy(ivContext);
#elif defined(HAVE_NETTLE)
sha1_ctx ivContext = context;
sha1_digest(&ivContext, sizeof(digest), digest);
#endif
m_decryptIV[i / (rounds / 16)] = digest[sizeof(digest) - 1];
}
}
#ifdef HAVE_OPENSSL
EVP_DigestFinal(context, digest, nullptr);
EVP_MD_CTX_destroy(context);
#elif defined(HAVE_NETTLE)
sha1_digest(&context, sizeof(digest), digest);
#endif
debug("digest: %s", *Util::FormatBuffer((const char*)digest, sizeof(digest)));
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
m_decryptKey[i * 4 + j] = digest[i * 4 + 3 - j];
}
}
debug("key: %s", *Util::FormatBuffer((const char*)m_decryptKey, sizeof(m_decryptKey)));
debug("iv: %s", *Util::FormatBuffer((const char*)m_decryptIV, sizeof(m_decryptIV)));
return true;
}
uint32_t __stdcall crev_ver3(uint8_t *archive_time, uint8_t *archive_name, uint8_t *seed, uint8_t *ini_file, uint8_t *ini_header, uint32_t *version, uint32_t *checksum, uint8_t *result){
uint32_t x = 0;
uint32_t y = 0;
uint32_t z = 0;
uint32_t lret;
uint8_t *files[5];
//uint8_t *tok;
uint8_t *buff;
uint8_t *buff2;
uint32_t archive_rev = 0;
uint32_t header_size = 0;
sha1_context sha;
lockdown_heep ldh;
uint32_t pe_file;
PE_IMAGE_NT_HEADERS *nt;
PE_IMAGE_SECTION_HEADER *sections;
const uint8_t *keys[] = {"Exe", "Util", "Network", "Screen"};
const uint32_t seeds[] = {
0xA1F3055A, 0x5657124C, 0x1780AB47, 0x80B3A410, 0xAF2179EA,
0x0837B808, 0x6F2516C6, 0xE3178148, 0x0FCF90B6, 0xF2F09516,
0x378D8D8C, 0x07F8E083, 0xB0EE9741, 0x7923C9AF, 0xCA11A05E,
0xD723C016, 0xFD545590, 0xFB600C2E, 0x684C8785, 0x58BEDE0B
};
sha.version = lSHA1;
sha1_reset(&sha);
if( (archive_name[14] < '0' || archive_name[14] > '1') ||
(archive_name[15] < '0' || archive_name[15] > '9')){
return CREV_UNKNOWN_REVISION;
}
archive_rev = ((archive_name[14] - '0') * 10) +
(archive_name[15] - '0');
buff = safe_malloc(MAX_PATH);
read_ini_new(ini_file, ini_header, "Path", "", buff, MAX_PATH);
files[0] = safe_malloc(MAX_PATH);
combine_paths(buff, "", files[0], MAX_PATH);
for(x = 1; x < 5; x++){
read_ini_new(ini_file, ini_header, (uint8_t*)keys[x-1], "\xFF", buff, MAX_PATH);
if(buff[0] == 0xFF){
for(y = 0; y < x; y++)
if(files[y] != NULL) free(files[y]);
sprintf_s(result, crev_max_result(), "%s\x00", keys[x-1]);
free(buff);
return CREV_MISSING_FILENAME;
}
files[x] = safe_malloc(MAX_PATH);
combine_paths(files[0], buff, files[x], MAX_PATH);
}
read_ini_new(ini_file, "CRev_Main", "LockdownPath", "", buff, MAX_PATH);
combine_paths(buff, "", files[0], MAX_PATH);
sprintf_s(files[0], MAX_PATH, "%s\\Lockdown-IX86-%02d.dll", files[0], archive_rev);
free(buff);
lockdown_shuffle_seed(seed);
buff = safe_malloc(0x40);
memset(buff, '6', 0x40);
for(x = 0; x < 0x10; x++)
buff[x] ^= seed[x];
sha1_input(&sha, buff, 0x40);
free(buff);
for(x = 0; x < 4; x++){
pe_file = pe_load_library(files[x]);
if(pe_file == 0){
sprintf_s(result, CREV_MAX_RESULT, files[x]);
for(z = 0; z < 5; z++) if(files[z] != NULL) free(files[z]);
return CREV_MISSING_FILE;
}
nt = (PE_IMAGE_NT_HEADERS*)(pe_file + ((PE_IMAGE_DOS_HEADER*)pe_file)->e_lfanew);
if(nt->OptionalHeader.NumberOfRvaAndSizes <= 0x0D){
for(z = 0; z < 5; z++) if(files[z] != NULL) free(files[z]);
pe_unload_library(pe_file);
return CREV_TOFEW_RVAS;
}
header_size = nt->OptionalHeader.SizeOfHeaders;
if((header_size % nt->OptionalHeader.FileAlignment) != 0)
header_size += (nt->OptionalHeader.FileAlignment - (header_size % nt->OptionalHeader.FileAlignment));
sha1_input(&sha, (uint8_t*)pe_file, header_size); //Hash the PE Header
lockdown_heep_create(&ldh);
lret = lockdown_proc_reloc(pe_file, &ldh);
if(lret != CREV_SUCCESS){
sprintf_s(result, CREV_MAX_RESULT, files[x]);
for(z = 0; z < 5; z++) if(files[z] != NULL) free(files[z]);
pe_unload_library(pe_file);
return lret;
}
lret = lockdown_proc_import(pe_file, &ldh);
if(lret != CREV_SUCCESS){
sprintf_s(result, CREV_MAX_RESULT, files[x]);
for(z = 0; z < 5; z++) if(files[z] != NULL) free(files[z]);
pe_unload_library(pe_file);
return lret;
}
lockdown_heep_sort(&ldh);
/*for(y = 0; y < ldh.cur_len; y += 0x10){
wwrite_to_file(tto_hex((uint8_t*)(ldh.mem + y), 16, FALSE));
wwrite_to_file("\n");
}*/
sections = (PE_IMAGE_SECTION_HEADER *)(pe_file + nt->FileHeader.SizeOfOptionalHeader + ((PE_IMAGE_DOS_HEADER*)pe_file)->e_lfanew + PE_SIZE_OF_NT_SIGNATURE + PE_IMAGE_SIZEOF_FILE_HEADER);
for(y = 0; y < nt->FileHeader.NumberOfSections; y++){
lret = lockdown_hash1(&sha, &ldh, (uint32_t)(§ions[y]), pe_file, seeds[archive_rev]);
if(lret != CREV_SUCCESS){
sprintf_s(result, CREV_MAX_RESULT, files[x]);
for(z = 0; z < 5; z++) if(files[z] != NULL) free(files[z]);
pe_unload_library(pe_file);
return lret;
}
}
lockdown_heep_cleanup(&ldh);
pe_unload_library(pe_file);
}
//Hash Screen Buffer
x = get_file_size(files[4]);
if(x == 0){
sprintf_s(result, CREV_MAX_RESULT, files[3]);
return CREV_MISSING_FILE;
}
buff = safe_malloc(x);
get_file_data(files[4], buff, x, 0);
sha1_input(&sha, buff, x);
free(buff);
sha1_input(&sha, "\x01\x00\x00\x00", 4); //Verify Return Address
sha1_input(&sha, "\x00\x00\x00\x00", 4); //Verify Module Offset
buff2 = safe_malloc(sha1_hash_size);
sha1_digest(&sha, buff2);
//wwrite_to_file(tto_hex(buff2, sha1_hash_size, FALSE)); wwrite_to_file("\n");
//Second SHA Pass
buff = safe_malloc(0x40);
memset(buff, '\\', 0x40);
for(x = 0; x < 0x10; x++)
buff[x] ^= seed[x];
sha1_reset(&sha);
sha1_input(&sha, buff, 0x40);
sha1_input(&sha, buff2, sha1_hash_size);
memset(buff2, 0, sha1_hash_size);
sha1_digest(&sha, buff2);
lockdown_shuffle_digest((uint8_t*)(&buff2[4]));
*version = crev_get_file_version(files[1]);
*checksum = (*(uint32_t*)&buff2[0]);
memcpy(result, (uint8_t*)(&buff2[4]), 0x10);
for(x = 0; x < 5; x++)
if(files[x] != NULL) free(files[x]);
return CREV_SUCCESS;
}
static void SHA1_Final(unsigned char digest[20], SHA_CTX *ctx)
{
sha1_digest(ctx, 20, digest);
}
int ws_handshake(wsh_t *wsh)
{
char key[256] = "";
char version[5] = "";
char proto[256] = "";
char proto_buf[384] = "";
char input[256] = "";
unsigned char output[SHA1_HASH_SIZE] = "";
char b64[256] = "";
char respond[512] = "";
ssize_t bytes;
char *p, *e = 0;
if (wsh->sock == ws_sock_invalid) {
return -3;
}
while((bytes = ws_raw_read(wsh, wsh->buffer + wsh->datalen, wsh->buflen - wsh->datalen, WS_BLOCK)) > 0) {
wsh->datalen += bytes;
if (strstr(wsh->buffer, "\r\n\r\n") || strstr(wsh->buffer, "\n\n")) {
break;
}
}
if (bytes > sizeof(wsh->buffer) -1) {
goto err;
}
*(wsh->buffer + wsh->datalen) = '\0';
if (strncasecmp(wsh->buffer, "GET ", 4)) {
goto err;
}
p = wsh->buffer + 4;
e = strchr(p, ' ');
if (!e) {
goto err;
}
wsh->uri = malloc((e-p) + 1);
strncpy(wsh->uri, p, e-p);
*(wsh->uri + (e-p)) = '\0';
cheezy_get_var(wsh->buffer, "Sec-WebSocket-Key", key, sizeof(key));
cheezy_get_var(wsh->buffer, "Sec-WebSocket-Version", version, sizeof(version));
cheezy_get_var(wsh->buffer, "Sec-WebSocket-Protocol", proto, sizeof(proto));
if (!*key) {
goto err;
}
snprintf(input, sizeof(input), "%s%s", key, WEBSOCKET_GUID);
sha1_digest(output, input);
b64encode((unsigned char *)output, SHA1_HASH_SIZE, (unsigned char *)b64, sizeof(b64));
if (*proto) {
snprintf(proto_buf, sizeof(proto_buf), "Sec-WebSocket-Protocol: %s\r\n", proto);
}
snprintf(respond, sizeof(respond),
"HTTP/1.1 101 Switching Protocols\r\n"
"Upgrade: websocket\r\n"
"Connection: Upgrade\r\n"
"Sec-WebSocket-Accept: %s\r\n"
"%s\r\n",
b64,
proto_buf);
respond[511] = 0;
if (ws_raw_write(wsh, respond, strlen(respond)) != (ssize_t)strlen(respond)) {
goto err;
}
wsh->handshake = 1;
return 0;
err:
if (!wsh->stay_open) {
snprintf(respond, sizeof(respond), "HTTP/1.1 400 Bad Request\r\n"
"Sec-WebSocket-Version: 13\r\n\r\n");
respond[511] = 0;
ws_raw_write(wsh, respond, strlen(respond));
ws_close(wsh, WS_NONE);
}
return -1;
}
unsigned char *hash(char *str) {
return sha1_digest(str);
}
static int
__archive_nettle_sha1final(archive_sha1_ctx *ctx, void *md)
{
sha1_digest(ctx, SHA1_DIGEST_SIZE, md);
return (ARCHIVE_OK);
}
void libmaus2::digest::SHA1::digest(uint8_t * digest) { sha1_digest(reinterpret_cast<sha1_ctx *>(ctx),digestlength,&digest[0]); }
int
pgp_put_rsa_sha1_signature(struct nettle_buffer *buffer,
const struct rsa_private_key *key,
const uint8_t *keyid,
unsigned type,
struct sha1_ctx *hash)
{
unsigned signature_start = buffer->size;
unsigned hash_end;
unsigned sub_packet_start;
uint8_t trailer[6];
mpz_t s;
/* Signature packet. The packet could reasonably be both smaller and
* larger than 192, so for simplicity we use the 4 octet header
* form. */
if (! (pgp_put_header(buffer, PGP_TAG_SIGNATURE, PGP_LENGTH_FOUR_OCTETS)
&& NETTLE_BUFFER_PUTC(buffer, 4) /* Version */
&& NETTLE_BUFFER_PUTC(buffer, type)
/* Could also be PGP_RSA_SIGN */
&& NETTLE_BUFFER_PUTC(buffer, PGP_RSA)
&& NETTLE_BUFFER_PUTC(buffer, PGP_SHA1)
&& pgp_put_uint16(buffer, 0))) /* Hashed subpacket length */
return 0;
hash_end = buffer->size;
sha1_update(hash,
hash_end - signature_start,
buffer->contents + signature_start);
trailer[0] = 4; trailer[1] = 0xff;
WRITE_UINT32(trailer + 2, buffer->size - signature_start);
sha1_update(hash, sizeof(trailer), trailer);
{
struct sha1_ctx hcopy = *hash;
uint8_t *p = nettle_buffer_space(buffer, 2);
if (!p)
return 0;
sha1_digest(&hcopy, 2, p);
}
/* One "sub-packet" field with the issuer keyid */
sub_packet_start = pgp_sub_packet_start(buffer);
if (!sub_packet_start)
return 0;
if (pgp_put_sub_packet(buffer, PGP_SUBPACKET_ISSUER_KEY_ID, 8, keyid))
{
pgp_sub_packet_end(buffer, sub_packet_start);
return 0;
}
mpz_init(s);
if (!(rsa_sha1_sign(key, hash, s)
&& pgp_put_mpi(buffer, s)))
{
mpz_clear(s);
return 0;
}
mpz_clear(s);
pgp_put_header_length(buffer, signature_start, 4);
return 1;
}
