void nsColorPicker::SetColor(const GdkRGBA* color)
{
mColor.Assign('#');
mColor += ToHexString(convertGdkRgbaComponent(color->red));
mColor += ToHexString(convertGdkRgbaComponent(color->green));
mColor += ToHexString(convertGdkRgbaComponent(color->blue));
}
void nsColorPicker::ReadValueFromColorSelection(GtkColorSelection* colorselection)
{
GdkColor rgba;
gtk_color_selection_get_current_color(colorselection, &rgba);
mColor.Assign('#');
mColor += ToHexString(convertGdkColorComponent(rgba.red));
mColor += ToHexString(convertGdkColorComponent(rgba.green));
mColor += ToHexString(convertGdkColorComponent(rgba.blue));
}
void nsColorPicker::ReadValueFromColorChooser(GtkWidget* color_chooser)
{
GdkColor rgba;
gtk_color_selection_get_current_color(
GTK_COLOR_SELECTION(gtk_color_selection_dialog_get_color_selection(
GTK_COLOR_SELECTION_DIALOG(color_chooser))),
&rgba);
mColor.AssignLiteral("#");
mColor += ToHexString(convertGdkColorComponent(rgba.red));
mColor += ToHexString(convertGdkColorComponent(rgba.green));
mColor += ToHexString(convertGdkColorComponent(rgba.blue));
}
void XrefBrowseDialog::setup(duint address, QString command)
{
if(mXrefInfo.refcount)
{
BridgeFree(mXrefInfo.references);
mXrefInfo.refcount = 0;
}
mCommand = command;
mAddress = address;
mPrevSelectionSize = 0;
ui->listWidget->clear();
if(DbgXrefGet(address, &mXrefInfo))
{
char disasm[GUI_MAX_DISASSEMBLY_SIZE] = "";
setWindowTitle(QString(tr("xrefs at %1")).arg(ToHexString(address)));
for(duint i = 0; i < mXrefInfo.refcount; i++)
{
if(GuiGetDisassembly(mXrefInfo.references[i].addr, disasm))
ui->listWidget->addItem(disasm);
else
ui->listWidget->addItem("???");
}
ui->listWidget->setCurrentRow(0);
}
ui->listWidget->setFocus();
}
mozilla::ipc::IPCResult
GMPDecryptorParent::RecvBatchedKeyStatusChanged(const nsCString& aSessionId,
InfallibleTArray<GMPKeyInformation>&& aKeyInfos)
{
LOGD(("GMPDecryptorParent[%p]::RecvBatchedKeyStatusChanged(sessionId='%s', KeyInfos len='%" PRIuSIZE "')",
this, aSessionId.get(), aKeyInfos.Length()));
if (mIsOpen) {
nsTArray<CDMKeyInfo> cdmKeyInfos(aKeyInfos.Length());
for (uint32_t i = 0; i < aKeyInfos.Length(); i++) {
LOGD(("GMPDecryptorParent[%p]::RecvBatchedKeyStatusChanged(keyId=%s, gmp-status=%d)",
this, ToHexString(aKeyInfos[i].keyId()).get(), aKeyInfos[i].status()));
// If the status is kGMPUnknown, we're going to forget(remove) that key info.
if (aKeyInfos[i].status() != kGMPUnknown) {
auto status = ToMediaKeyStatus(aKeyInfos[i].status());
cdmKeyInfos.AppendElement(CDMKeyInfo(aKeyInfos[i].keyId(),
dom::Optional<dom::MediaKeyStatus>(status)));
} else {
cdmKeyInfos.AppendElement(CDMKeyInfo(aKeyInfos[i].keyId()));
}
}
mCallback->BatchedKeyStatusChanged(aSessionId, cdmKeyInfos);
}
return IPC_OK();
}
std::string ToUrlFormat(const unsigned char* const data, int numbytes)
{
std::string r;
for (int i = 0; i < numbytes; i++)
{
unsigned char c = (char)data[i];
// Replace c with e.g. %20 - i.e. '%' followed by c in hex.
r += std::string(1, '%');
r += ToHexString((unsigned int)c);
/*
if (IsUrlPrintable(c))
{
r += std::string(1, c);
}
else
{
// Replace c with e.g. %20 - i.e. '%' followed by c in hex.
r += std::string(1, '%');
r += ToHexString((unsigned int)c);
}
*/
}
return r;
}
int main()
{
std::cout << ToHexString(200).c_str() << std::endl;
//std::cout << ToOctalString(200).c_str() << std::endl;
//std::cout << ToBinaryString(200).c_str() << std::endl;
std::cin.get();
return 0;
}
void PrintStringAndHex(signed char * const pString,unsigned int Value)
{
xSemaphoreTake(UartMutex,portMAX_DELAY);
WriteTxBuffer(pString);
ToHexString(Value,ConversionString);
WriteTxBuffer(ConversionString);
WriteTxBuffer("\r\n");
xSemaphoreGive(UartMutex);
}
static nsCString
CryptoInfo(const GMPUniquePtr<GMPVideoEncodedFrame>& aInputFrame)
{
const GMPEncryptedBufferMetadata* crypto = aInputFrame->GetDecryptionData();
if (!crypto) {
return EmptyCString();
}
return nsPrintfCString(" kid=%s",
ToHexString(crypto->KeyId(), crypto->KeyIdSize()).get());
}
// ////////////////////////////////////////////////////////////////////////////
std::string ToHexStringDebug(const StreamDatum *begin_ptr,
const StreamDatum *end_ptr)
{
std::ostringstream o_str;
const StreamDatum *tmp_end_ptr = std::min(end_ptr, begin_ptr + 10);
o_str << std::left << std::setw((10 * 2) + 9) <<
ToHexString(begin_ptr, tmp_end_ptr) << std::right <<
(((end_ptr - begin_ptr) > 10) ? ">" : " ");
return(o_str.str());
}
std::string EncodeStr(const std::string& plainMsg)
{
std::string result;
int s = static_cast<int>(plainMsg.size());
for (int i = 0; i < s; i++)
{
unsigned char c = plainMsg[i];
result += ToHexString(c);
}
return result;
}
mozilla::ipc::IPCResult
GMPDecryptorParent::RecvSessionMessage(const nsCString& aSessionId,
const GMPSessionMessageType& aMessageType,
nsTArray<uint8_t>&& aMessage)
{
LOGD(("GMPDecryptorParent[%p]::RecvSessionMessage(sessionId='%s', type=%d, msg='%s')",
this, aSessionId.get(), aMessageType, ToHexString(aMessage).get()));
if (!mIsOpen) {
NS_WARNING("Trying to use a dead GMP decrypter!");
return IPC_FAIL_NO_REASON(this);
}
mCallback->SessionMessage(aSessionId, ToMediaKeyMessageType(aMessageType), aMessage);
return IPC_OK();
}
void
GMPDecryptorParent::UpdateSession(uint32_t aPromiseId,
const nsCString& aSessionId,
const nsTArray<uint8_t>& aResponse)
{
LOGD(("GMPDecryptorParent[%p]::UpdateSession(sessionId='%s', promiseId=%u response='%s')",
this, aSessionId.get(), aPromiseId, ToHexString(aResponse).get()));
if (!mIsOpen) {
NS_WARNING("Trying to use a dead GMP decrypter!");
return;
}
// Caller should ensure parameters passed in from JS are valid.
MOZ_ASSERT(!aSessionId.IsEmpty() && !aResponse.IsEmpty());
Unused << SendUpdateSession(aPromiseId, aSessionId, aResponse);
}
void
GMPDecryptorParent::CreateSession(uint32_t aCreateSessionToken,
uint32_t aPromiseId,
const nsCString& aInitDataType,
const nsTArray<uint8_t>& aInitData,
GMPSessionType aSessionType)
{
LOGD(("GMPDecryptorParent[%p]::CreateSession(token=%u, promiseId=%u, aInitData='%s')",
this, aCreateSessionToken, aPromiseId, ToHexString(aInitData).get()));
if (!mIsOpen) {
NS_WARNING("Trying to use a dead GMP decrypter!");
return;
}
// Caller should ensure parameters passed in from JS are valid.
MOZ_ASSERT(!aInitDataType.IsEmpty() && !aInitData.IsEmpty());
Unused << SendCreateSession(aCreateSessionToken, aPromiseId, aInitDataType, aInitData, aSessionType);
}
std::string ToUrlFormat(const BinaryData& d)
{
std::string r;
const int size = d.size();
for (int i = 0; i < size; i++)
{
unsigned char c = d[i];
if (IsUrlPrintable(c))
{
r += std::string(1, c);
}
else
{
// Replace c with e.g. %20 - i.e. '%' followed by c in hex.
r += std::string(1, '%');
r += ToHexString((unsigned int)c);
}
}
return r;
}
// Replace spaces with %20, etc.
std::string ToUrlFormat(const std::string& s)
{
std::string r;
for (unsigned int i = 0; i < s.length(); i++)
{
unsigned char c = s[i];
if (IsUrlPrintable(c))
{
r += std::string(1, c);
}
else
{
// Replace c with e.g. %20 - i.e. '%' followed by c in hex.
r += std::string(1, '%');
r += ToHexString(c);
}
}
return r;
}
QString CapstoneTokenizer::printValue(const TokenValue & value, bool expandModule, int maxModuleLength) const
{
QString labelText;
// char label_[MAX_LABEL_SIZE] = "";
// char module_[MAX_MODULE_SIZE] = "";
QString moduleText;
duint addr = value.value;
// bool bHasLabel = DbgGetLabelAt(addr, SEG_DEFAULT, label_);
// if(!bHasLabel) //handle function+offset
// {
// duint start;
// if(DbgFunctionGet(addr, &start, nullptr) && DbgGetLabelAt(start, SEG_DEFAULT, label_))
// {
// labelText = QString("%1+%2").arg(label_).arg(ToHexString(addr - start));
// bHasLabel = true;
// }
// }
// else
// labelText = QString(label_);
// bool bHasModule = (expandModule && DbgGetModuleAt(addr, module_) && !QString(labelText).startsWith("JMP.&"));
// moduleText = QString(module_);
// if(maxModuleLength != -1)
// moduleText.truncate(maxModuleLength);
// if(moduleText.length())
// moduleText += ".";
QString addrText = ToHexString(addr);
QString finalText;
// if(bHasLabel && bHasModule) //<module.label>
// finalText = QString("<%1%2>").arg(moduleText).arg(labelText);
// else if(bHasModule) //module.addr
// finalText = QString("%1%2").arg(moduleText).arg(addrText);
// else if(bHasLabel) //<label>
// finalText = QString("<%1>").arg(labelText);
// else
finalText = addrText;
return finalText;
}
nsCString
ToHexString(const nsTArray<uint8_t>& aBytes)
{
return ToHexString(aBytes.Elements(), aBytes.Length());
}
std::wstring CStringUtils::ToHexWString( BYTE* pSrc, int nSrcLen )
{
std::string s = ToHexString(pSrc, nSrcLen);
return std::wstring(s.begin(), s.end());
}
// ////////////////////////////////////////////////////////////////////////////
std::string ToHexString(std::size_t data_length, const StreamDatum *data_ptr)
{
return(ToHexString(data_ptr, data_ptr + data_length));
}
void NtfyPacket(std::shared_ptr<GlobalGrid::VSocket> socket,unsigned char* packetData, size_t packetLength) {
if(sessions.find(socket) == sessions.end()) {
//We should have an AES key in our packet here encrypted with our public key.
//Packet header -- thumbprint (16 bytes) (unverified data element), session key (variable length, encrypted)
if(packetLength<=16) {
return;
}
void* packet = RSA_Decrypt(privkey,packetData+16,packetLength-16);
if(packet == 0) { //Decryption failure.
return;
}
unsigned char* buffer;
size_t sz;
GlobalGrid::Buffer_Get(packet,&buffer,&sz);
if(sz>=32) {
//We have a new Session.
Session route(socket,buffer,packetData);
sessions.insert(route);
//Respond with ACK, which verifies our identity
//Send challenge to verify remote identity.
char hexprint[33];
ToHexString((unsigned char*)route.claimedThumbprint,16,hexprint);
hexprint[32] = 0;
void* remoteKey = DB_FindAuthority(hexprint);
if(remoteKey) {
SendChallenge(remoteKey,route,socket);
}else {
//We don't have a remote key. Request it.
unsigned char izard[16];
memset(izard,0,16);
izard[0] = 2;
aes_encrypt(route.key,izard);
socket->Send(izard,16);
}
GlobalGrid::GGObject_Free(packet);
}else {
GlobalGrid::GGObject_Free(packet);
}
}else {
//Bind to existing Session.
if(packetLength % 16 != 0) {
//Invalid packet.
return;
}
Session session = *sessions.find(socket);
for(size_t i = 0;i<packetLength;i+=16) {
aes_decrypt(session.key,packetData+i);
}
switch(*packetData) {
case 0:
//Challenge request
{
//Decrypt challenge
uint16_t len;
memcpy(&len,packetData+1,2);
void* challenge = RSA_Decrypt(privkey,packetData+1+2,len);
if(challenge == 0) {
return;
}
unsigned char* challenge_bytes;
size_t challenge_sz;
GlobalGrid::Buffer_Get(challenge,&challenge_bytes,&challenge_sz);
if(challenge_sz != 16) {
GlobalGrid::GGObject_Free(challenge);
return;
}
unsigned char response[32];
memset(response,0,32);
response[0] = 1;
memcpy(response+1,challenge_bytes,16);
aes_encrypt(session.key,response);
aes_encrypt(session.key,response+16);
socket->Send(response,32);
GlobalGrid::GGObject_Free(challenge);
}
break;
case 1:
{
//Response to challenge (identity verification)
if(memcmp(session.challenge,packetData+1,16) == 0) {
session.verified = true;
printf("Identity verified.\n");
}
}
break;
case 2:
{
//Request for public encryptionKey.
void* key = RSA_Export(privkey,false);
unsigned char* key_bytes;
size_t key_size;
GlobalGrid::Buffer_Get(key,&key_bytes,&key_size);
size_t aligned = key_size+1;
aligned+=16-(aligned % 16);
unsigned char* packet = new unsigned char[aligned];
memcpy(packet+1,key_bytes,key_size);
packet[0] = 3;
for(size_t i = 0;i<aligned;i+=16) {
aes_encrypt(session.key,packet+i);
}
socket->Send(packet,aligned);
delete[] packet;
GlobalGrid::GGObject_Free(key);
}
break;
case 3:
{
//Received public encryption key
void* key = RSA_Key(packetData+1,packetLength-1);
char thumbprint[33];
RSA_thumbprint(key,thumbprint);
thumbprint[32] = 0;
void* obj = DB_FindAuthority(thumbprint);
if(obj == 0) {
void* keybin = RSA_Export(key,false);
unsigned char* cert;
size_t cert_len;
GlobalGrid::Buffer_Get(keybin,&cert,&cert_len);
DB_Insert_Certificate(thumbprint,cert,cert_len,false);
GlobalGrid::GGObject_Free(keybin);
if(session.verified == false) {
//TODO: Send verification request
SendChallenge(key,session,socket);
}
}else {
RSA_Free(obj);
}
}
break;
case 4:
{
//Route packet
packetData++;
unsigned char ttl = *packetData;
packetData++;
//Intended destination
GlobalGrid::Guid dest;
memcpy(dest.value,packetData,16);
packetData+=16;
GlobalGrid::Guid localThumbprint;
RSA_thumbprint(privkey,(unsigned char*)localThumbprint.value);
uint32_t packetSize;
memcpy(&packetSize,packetData,4);
packetData+=16;
if(dest == localGuid) {
printf("TODO: Packet destined for ourselves\n");
return;
}
SendPacket(packetData,packetSize,ttl,dest,session.claimedThumbprint);
}
break;
}
}
}
HRESULT
modmd5(LPSTR *hexhash)
{
HRESULT hRes;
HANDLE hFile = NULL;
DEBUG_MODULE_PARAMETERS ModParams;
HCRYPTPROV hCryptProv = NULL;
HCRYPTHASH hHash = NULL;
BYTE *pbHashData = NULL;
BYTE buffer[BUFSIZE];
DWORD cbHash;
DWORD cbRead = 0;
BOOL bResult = FALSE;
/*
msdn: returns parameters for modules in the target.
*/
hRes=g_ExtSymbols->GetModuleParameters(1, &g_Base, 0, &ModParams);
if(FAILED(hRes))
{
dprintf("[sync] modcheck: failed get module parameters\n");
return E_FAIL;
}
dprintf("[sync] modcheck:\n"
" File: %s\n"
" Size: 0x%x\n"
" TimeDateStamp: 0x%x\n", g_NameBuffer, ModParams.Size, ModParams.TimeDateStamp);
hRes=E_FAIL;
hFile = CreateFile(g_NameBuffer, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
dprintf("[sync] failed at opening file: %d\n", GetLastError());
return hRes;
}
if (!(CryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)))
{
dprintf("[sync] CryptAcquireContext failed\n");
goto Exit;
}
if (!(CryptCreateHash(hCryptProv, CALG_MD5, NULL, NULL, &hHash)))
{
dprintf("[sync] CryptCreateHash failed\n");
goto Exit;
}
while (bResult = ReadFile(hFile, buffer, BUFSIZE, &cbRead, NULL))
{
if (cbRead == 0)
break;
if (!(CryptHashData(hHash, buffer, cbRead, NULL)))
{
dprintf("[sync] CryptHashData failed\n");
goto Exit;
}
}
if (!bResult)
{
dprintf("[sync] ReadFile failed\n");
goto Exit;
}
if (!(CryptGetHashParam(hHash, HP_HASHVAL, NULL, &cbHash, 0)))
{
dprintf("[sync] CryptGetHashParam failed\n");
goto Exit;
}
pbHashData = (BYTE *) malloc(cbHash);
if (pbHashData==NULL){
dprintf("[sync] failed at allocate buffer: %d\n", GetLastError());
goto Exit;
}
if (!(CryptGetHashParam(hHash, HP_HASHVAL, pbHashData, &cbHash, 0)))
{
dprintf("[sync] CryptGetHashParam failed\n");
goto Exit;
}
hRes = ToHexString((const byte *)pbHashData, (unsigned int)cbHash, hexhash);
Exit:
if (hFile)
CloseHandle(hFile);
if (pbHashData)
free(pbHashData);
if (hHash)
CryptDestroyHash(hHash);
if (hCryptProv)
CryptReleaseContext(hCryptProv,0);
return hRes;
}
std::string GLIB::GetAddress(unsigned int val)
{
return ToHexString(val);
}
std::string GLIB::GetMask(unsigned int val)
{
return ToHexString(val);
}
nsString
MediaKeyStatusMap::GetKeyIDAsHexString(uint32_t aIndex) const
{
MOZ_ASSERT(aIndex < GetIterableLength());
return NS_ConvertUTF8toUTF16(ToHexString(mStatuses[aIndex].mKeyId));
}
