static void interactive(int fd)
{
struct input_event ev;
uint32_t last_scan = 0;
uint16_t last_key = 0;
int has_scan; /* boolean */
int has_key; /* 0: none, 1: release, 2: press */
/* grab input device */
ioctl(fd, EVIOCGRAB, 1);
puts("Press ESC to finish, or Control-C if this device is not your primary keyboard");
has_scan = has_key = 0;
while (read_event(fd, &ev)) {
/* Drivers usually send the scan code first, then the key code,
* then a SYN. Some drivers (like thinkpad_acpi) send the key
* code first, and some drivers might not send SYN events, so
* keep a robust state machine which can deal with any of those
*/
if (ev.type == EV_MSC && ev.code == MSC_SCAN) {
if (has_scan) {
fputs("driver did not send SYN event in between key events; previous event:\n",
stderr);
print_key(last_scan, last_key, has_scan, has_key);
has_key = 0;
}
last_scan = ev.value;
has_scan = 1;
/*printf("--- got scan %u; has scan %i key %i\n", last_scan, has_scan, has_key); */
}
else if (ev.type == EV_KEY) {
if (has_key) {
fputs("driver did not send SYN event in between key events; previous event:\n",
stderr);
print_key(last_scan, last_key, has_scan, has_key);
has_scan = 0;
}
last_key = ev.code;
has_key = 1 + ev.value;
/*printf("--- got key %hu; has scan %i key %i\n", last_key, has_scan, has_key);*/
/* Stop on ESC */
if (ev.code == KEY_ESC && ev.value == 0)
break;
}
else if (ev.type == EV_SYN) {
/*printf("--- got SYN; has scan %i key %i\n", has_scan, has_key);*/
print_key(last_scan, last_key, has_scan, has_key);
has_scan = has_key = 0;
}
}
/* release input device */
ioctl(fd, EVIOCGRAB, 0);
}
static void cmap_notify_fn(
cmap_handle_t cmap_handle,
cmap_track_handle_t cmap_track_handle,
int32_t event,
const char *key_name,
struct cmap_notify_value new_val,
struct cmap_notify_value old_val,
void *user_data)
{
switch (event) {
case CMAP_TRACK_ADD:
printf("create> ");
print_key(cmap_handle, key_name, new_val.len, new_val.data, new_val.type);
break;
case CMAP_TRACK_DELETE:
printf("delete> ");
print_key(cmap_handle, key_name, old_val.len, old_val.data, old_val.type);
break;
case CMAP_TRACK_MODIFY:
printf("modify> ");
print_key(cmap_handle, key_name, new_val.len, new_val.data, new_val.type);
break;
default:
printf("unknown change> ");
break;
}
}
/*
* Routine:
* Purpose:
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int
pr_w_store_returns(void *row)
{
struct W_STORE_RETURNS_TBL *r;
if (row == NULL)
r = &g_w_store_returns;
else
r = row;
print_start(STORE_RETURNS);
print_key(SR_RETURNED_DATE_SK, r->sr_returned_date_sk, 1);
print_key(SR_RETURNED_TIME_SK, r->sr_returned_time_sk, 1);
print_key(SR_ITEM_SK, r->sr_item_sk, 1);
print_key(SR_CUSTOMER_SK, r->sr_customer_sk, 1);
print_key(SR_CDEMO_SK, r->sr_cdemo_sk, 1);
print_key(SR_HDEMO_SK, r->sr_hdemo_sk, 1);
print_key(SR_ADDR_SK, r->sr_addr_sk, 1);
print_key(SR_STORE_SK, r->sr_store_sk, 1);
print_key(SR_REASON_SK, r->sr_reason_sk, 1);
print_key(SR_TICKET_NUMBER, r->sr_ticket_number, 1);
print_integer(SR_PRICING_QUANTITY, r->sr_pricing.quantity, 1);
print_decimal(SR_PRICING_NET_PAID, &r->sr_pricing.net_paid, 1);
print_decimal(SR_PRICING_EXT_TAX, &r->sr_pricing.ext_tax, 1);
print_decimal(SR_PRICING_NET_PAID_INC_TAX, &r->sr_pricing.net_paid_inc_tax, 1);
print_decimal(SR_PRICING_FEE, &r->sr_pricing.fee, 1);
print_decimal(SR_PRICING_EXT_SHIP_COST, &r->sr_pricing.ext_ship_cost, 1);
print_decimal(SR_PRICING_REFUNDED_CASH, &r->sr_pricing.refunded_cash, 1);
print_decimal(SR_PRICING_REVERSED_CHARGE, &r->sr_pricing.reversed_charge, 1);
print_decimal(SR_PRICING_STORE_CREDIT, &r->sr_pricing.store_credit, 1);
print_decimal(SR_PRICING_NET_LOSS, &r->sr_pricing.net_loss, 0);
print_end(STORE_RETURNS);
return(0);
}
static int poll_events(void)
{
gx_event ev;
while (gx_poll(&ev)) {
switch (ev.type) {
case GX_ev_quit:
return 1;
case GX_ev_keydown:
print_key(ev.key, 1);
if (ev.key == GX_key_esc)
return 1;
else if (ev.key == 'f') {
limitfps ^= 1;
printf("limitfps: %d\n", limitfps);
} else if (ev.key == 'm') {
pmouse ^= 1;
printf("pmouse: %d\n", pmouse);
}
break;
case GX_ev_keyup:
print_key(ev.key, 0);
break;
case GX_ev_keychar:
print_char(ev.key);
break;
case GX_ev_mouse:
if (pmouse)
printf("mouse: %3d,%3d\n", (int)(ev.mx*XRES), (int)(ev.my*YRES));
break;
}
}
return 0;
}
// keyboard service routine
void keyboard_routine(void) {
struct list_head *e;
struct task_struct *t;
unsigned char c = inb(0x60);
if ((c & 0x80) == 0) { // make
char aux = char_map[c&0x7F];
if (aux != '\0') {
print_key(aux);
add_key(aux);
if (threads_waiting()) {
//sys_write(1,"esperant",8);
e = list_first(&key_buffer.keyboardqueue);
t = list_head_to_task_struct(e);
if (can_read(t->num_chars_to_read)) {
sys_write(1,"llegim",6);
list_del(e);
list_add_tail(e, &readyqueue);
}
}
//char b[1];
//itoa(current()->num_chars_to_read,b);
//sys_write(1,b,1);
//print_buffer(6);
}
else {
print_key('C');
}
}
else { // break
// do nothing
}
}
/*
* Routine:
* Purpose:
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int
pr_w_customer(void *row)
{
struct W_CUSTOMER_TBL *r;
if (row == NULL)
r = &g_w_customer;
else
r = row;
print_start(CUSTOMER);
print_key(C_CUSTOMER_SK, r->c_customer_sk, 1);
print_varchar(C_CUSTOMER_ID, r->c_customer_id, 1);
print_key(C_CURRENT_CDEMO_SK, r->c_current_cdemo_sk, 1);
print_key(C_CURRENT_HDEMO_SK, r->c_current_hdemo_sk, 1);
print_key(C_CURRENT_ADDR_SK, r->c_current_addr_sk, 1);
print_integer(C_FIRST_SHIPTO_DATE_ID, r->c_first_shipto_date_id, 1);
print_integer(C_FIRST_SALES_DATE_ID, r->c_first_sales_date_id, 1);
print_varchar(C_SALUTATION, r->c_salutation, 1);
print_varchar(C_FIRST_NAME, r->c_first_name, 1);
print_varchar(C_LAST_NAME, r->c_last_name, 1);
print_boolean(C_PREFERRED_CUST_FLAG, r->c_preferred_cust_flag, 1);
print_integer(C_BIRTH_DAY, r->c_birth_day, 1);
print_integer(C_BIRTH_MONTH, r->c_birth_month, 1);
print_integer(C_BIRTH_YEAR, r->c_birth_year, 1);
print_varchar(C_BIRTH_COUNTRY, r->c_birth_country, 1);
print_varchar(C_LOGIN, &r->c_login[0], 1);
print_varchar(C_EMAIL_ADDRESS, &r->c_email_address[0], 1);
print_integer(C_LAST_REVIEW_DATE, r->c_last_review_date, 0);
print_end(CUSTOMER);
return(0);
}
void ls_recv_playok(unsigned char *raw, unsigned char *sessionkey_p1, unsigned char *sessionkey_p2)
{
printf("[!] Проверка возможности подключения успешно произведена! \n");
memcpy(sessionkey_p1,raw+3,4);
memcpy(sessionkey_p2,raw+7,4);
printf("[!] Задан SessionKey2: ");
print_key(sessionkey_p1,4);
print_key(sessionkey_p2,4);
printf("\n");
}
void ls_recv_logok(unsigned char* raw, unsigned char* sessionkey_p1, unsigned char* sessionkey_p2)
{
printf("[!] Авторизация на логин-сервере успешно произведена!\n");
memcpy(sessionkey_p1,raw+3,4);
memcpy(sessionkey_p2,raw+7,4);
printf("[!] Задан SessionKey1: ");
print_key(sessionkey_p1,4);
print_key(sessionkey_p2,4);
printf("\n");
}
bool x11_hotkeys::grab_keys(Display *dpy, Keys_t keys[], int nb_keys)
{
int i;
int min, max;
int screen;
XDisplayKeycodes(dpy, &min, &max);
#ifdef DEBUG
printf("\n");
printf("min_keycode=%d max_keycode=%d (ie: know keycodes)\n",
min, max);
#endif
for (i = 0; i < nb_keys; i++) {
#ifdef DEBUG
print_key(dpy, &keys[i]);
#endif
if (keys[i].type == SYM) {
for (screen = 0; screen < ScreenCount (dpy); screen++) {
my_grab_key(dpy, XKeysymToKeycode(dpy, keys[i].key.sym),
keys[i].modifier, RootWindow(dpy, screen));
}
} else if (keys[i].type == BUTTON) {
for (screen = 0; screen < ScreenCount (dpy); screen++) {
my_grab_button(dpy, keys[i].key.button, keys[i].modifier,
RootWindow (dpy, screen));
}
} else {
if (keys[i].key.code >= min && keys[i].key.code <= max) {
for (screen = 0; screen < ScreenCount (dpy); screen++) {
my_grab_key (dpy, keys[i].key.code, keys[i].modifier,
RootWindow (dpy, screen));
}
} else {
#ifdef DEBUG
print_key (dpy, &keys[i]);
fprintf (stderr,
" The keycode %d cannot be used, as it's not between the\n"
" min(%d) and max(%d) keycode of your keyboard.\n"
" Please increase the 'maximum' value in\n"
" /usr/X11R6/lib/X11/xkb/keycodes/xfree86,\n"
" then restart X.\n", keys[i].key.code, min, max);
#endif
return false;
}
}
}
return true;
}
int main(int argc, char *argv[]) {
gcry_mpi_t g,p,M,N,pw,t1,t2;
size_t scanned;
int iterations, keySize;
g = gcry_mpi_new(0);
p = gcry_mpi_new(0);
M = gcry_mpi_new(0);
N = gcry_mpi_new(0);
pw = gcry_mpi_new(0);
t1 = gcry_mpi_new(0);
t2 = gcry_mpi_new(0);
/* MODP_2048 */
const char* pString = "00FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA237327FFFFFFFFFFFFFFFF";
const char* gString = "2";
/* password */
const char* pwd = "My$Very=Secure;Password";
const char* salt = "abcdefghijklmno";
iterations = 1000;
keySize = 32;
/* read p and g */
gcry_mpi_scan(&g, GCRYMPI_FMT_HEX, gString, 0, &scanned);
gcry_mpi_scan(&p, GCRYMPI_FMT_HEX, pString, 0, &scanned);
/* hash password */
char* result = calloc(keySize, sizeof(char));
gcry_kdf_derive(pwd, strlen(pwd), GCRY_KDF_PBKDF2, GCRY_MD_SHA256, salt, strlen(salt), iterations, keySize, result);
gcry_mpi_scan(&pw, GCRYMPI_FMT_STD, result, strlen((const char*)result), &scanned);
/* create M and N */
gen_rand(t1, p);
gen_rand(t2, p);
gcry_mpi_powm(M, g, t1, p);
gcry_mpi_powm(N, g, t2, p);
/* run test ... */
struct spake_session client = spake_init(0, g, p, M, N, pw, keySize); /* client */
struct spake_session server = spake_init(1, g, p, M, N, pw, keySize); /* server */
spake_next(&client, server.X);
spake_next(&server, client.X);
print_key(client.k, keySize, "k1");
print_key(server.k, keySize, "k2");
if (strncmp(client.k, server.k, keySize) == 0)
printf("Successful SPAKE session :)\n");
else
printf("Sorry, error in SPAKE session :(\n");
return 0;
}
static void decrypt_password(uint8_t *encryptkey, uint8_t *IV, uint8_t *integrity){
char password[128];
ask_password(password, sizeof(password));
#ifdef CRYPTO_DEBUG
print_key("encrypt_salt",descriptor.encryption_salt, sizeof(descriptor.encryption_salt));
print_key("password salt", descriptor.password_salt, sizeof(descriptor.password_salt));
#endif
compute_session_keys_password(
password, descriptor.hash_loops,
encryptkey, IV, integrity,
descriptor.encryption_salt,
descriptor.password_salt);
ZERO(password);
}
/*
* Routine:
* Purpose:
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int
pr_s_item(void *pSrc)
{
struct W_ITEM_TBL *r;
if (pSrc == NULL)
r = &g_w_item;
else
r = pSrc;
print_start(S_ITEM);
print_varchar(S_ITEM_ID, r->i_item_id, 1);
print_varchar(S_ITEM_DESC, r->i_item_desc, 1);
print_decimal(S_ITEM_LIST_PRICE, &r->i_current_price, 1);
print_decimal(S_ITEM_WHOLESALE_COST, &r->i_wholesale_cost, 1);
print_varchar(S_ITEM_SIZE, r->i_size, 1);
print_varchar(S_ITEM_FORMULATION, r->i_formulation, 1);
print_varchar(S_ITEM_FLAVOR, r->i_color, 1);
print_varchar(S_ITEM_UNITS, r->i_units, 1);
print_varchar(S_ITEM_CONTAINER, r->i_container, 1);
print_key(S_ITEM_MANAGER_ID, r->i_manager_id, 0);
print_end(S_ITEM);
return(0);
}
/*
* Routine:
* Purpose:
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int
pr_s_web_return(void *pSrc)
{
struct S_WEB_RETURNS_TBL *r;
if (pSrc == NULL)
r = &g_s_web_returns;
else
r = pSrc;
print_start(S_WEB_RETURNS);
print_id(S_WRET_SITE_ID, r->kSiteID, 1);
print_key(S_WRET_ORDER_ID,r->kOrderID, 1);
print_integer(S_WRET_LINE_NUMBER, r->nLineNumber, 1);
print_id(S_WRET_ITEM_ID, r->kItemID, 1);
print_id(S_WRET_RETURN_CUST_ID, r->kReturningCustomerID, 1);
print_id(S_WRET_REFUND_CUST_ID,r->kRefundedCustomerID, 1);
print_date(S_WRET_RETURN_DATE, r->dtReturnDate.julian, 1);
print_time(S_WRET_RETURN_TIME, r->kReturnTime, 1);
print_integer(S_WRET_PRICING, r->Pricing.quantity, 1);
print_decimal(S_WRET_PRICING, &r->Pricing.ext_sales_price, 1);
print_decimal(S_WRET_PRICING, &r->Pricing.ext_tax, 1);
print_decimal(S_WRET_PRICING, &r->Pricing.fee, 1);
print_decimal(S_WRET_PRICING, &r->Pricing.ext_ship_cost, 1);
print_decimal(S_WRET_PRICING, &r->Pricing.refunded_cash, 1);
print_decimal(S_WRET_PRICING, &r->Pricing.reversed_charge, 1);
print_decimal(S_WRET_PRICING, &r->Pricing.store_credit, 1);
print_id(S_WRET_REASON_ID, r->kReasonID, 0);
print_end(S_WEB_RETURNS);
return(0);
}
void
print_class(const struct tesla_class *c)
{
static const char *DEBUG_NAME = "libtesla.class.state";
if (!tesla_debugging(DEBUG_NAME))
return;
print("----\n");
print("struct tesla_class @ 0x%tx {\n", (intptr_t) c);
print(" name: '%s',\n", c->tc_automaton->ta_name);
print(" description: '[...]',\n"); // TL;DR
print(" scope: ");
switch (c->tc_context) {
case TESLA_CONTEXT_THREAD: print("thread-local\n"); break;
case TESLA_CONTEXT_GLOBAL: print("global\n"); break;
default:
print("UNKNOWN (0x%x)\n", c->tc_context);
}
print(" limit: %d\n", c->tc_limit);
print(" %d/%d instances\n", c->tc_limit - c->tc_free, c->tc_limit);
for (uint32_t i = 0; i < c->tc_limit; i++) {
const struct tesla_instance *inst = c->tc_instances + i;
if (!tesla_instance_active(inst))
continue;
print(" %2u: state %d, ", i, inst->ti_state);
print_key(DEBUG_NAME, &inst->ti_key);
print("\n");
}
print("}\n");
print("----\n");
}
/*
* Routine:
* Purpose:
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int
pr_s_purchase(void *pSrc)
{
struct S_PURCHASE_TBL *r;
char szKey[RS_BKEY + 1];
if (pSrc == NULL)
r = &g_s_purchase;
else
r = pSrc;
print_start(S_PURCHASE);
print_key(S_PURCHASE_ID, r->kID, 1);
mk_bkey(szKey, r->kID, 0);
mk_bkey(szKey, r->kStoreID, 0);
print_varchar(S_PURCHASE_STORE_ID, szKey, 1);
mk_bkey(szKey, r->kCustomerID, 0);
print_varchar(S_PURCHASE_CUSTOMER_ID, szKey, 1);
print_date(S_PURCHASE_DATE, r->dtPurchaseDate.julian, 1);
print_integer(S_PURCHASE_TIME, r->nPurchaseTime, 1);
print_integer(S_PURCHASE_REGISTER, r->nRegister, 1);
print_integer(S_PURCHASE_CLERK, r->nClerk, 1);
print_varchar(S_PURCHASE_COMMENT, r->szComment, 0);
print_end(S_PURCHASE);
return(0);
}
int main(int argc, char *argv[])
{
if (argc < 2) {
printf("usage: ./cracker public_key(or beginning of one in hex format)\n");
return 0;
}
long long unsigned int num_tries = 0;
uint32_t len = strlen(argv[1]) / 2;
unsigned char *key = hex_string_to_bin(argv[1]);
uint8_t pub_key[32], priv_key[32], c_key[32];
if (len > 32) {
len = 32;
}
memcpy(c_key, key, len);
free(key);
randombytes(priv_key, 32);
while (1) {
crypto_scalarmult_curve25519_base(pub_key, priv_key);
uint32_t i;
if (memcmp(c_key, pub_key, len) == 0) {
break;
}
for (i = 32; i != 0; --i) {
priv_key[i - 1] += 1;
if (priv_key[i - 1] != 0) {
break;
}
}
++num_tries;
}
printf("Public key:\n");
print_key(pub_key);
printf("\nPrivate key:\n");
print_key(priv_key);
printf("\n %llu keys tried\n", num_tries);
return 0;
}
/* Entry point */
int main (int argc, char *argv[])
{
/* Initialize SDL subsystems - in this case, only video. */
if (SDL_Init (SDL_INIT_VIDEO) < 0) {
fprintf (stderr, "Unable to init SDL: %s\n", SDL_GetError ());
exit (1);
}
/* Register SDL_Quit to be called at exit;
* makes sure things are cleaned up when we quit. */
atexit (SDL_Quit);
/* Attempt to create a 640x480 window with 32 bit pixels. */
screen = SDL_SetVideoMode (640, 480, 32, SDL_SWSURFACE);
/* If we fail, return error. */
if (screen == NULL) {
fprintf (stderr, "Unable to set 640x480 video: %s\n", SDL_GetError ());
exit (1);
}
/* Main loop: loop forever. */
while (1) {
/* Render stuff */
render ();
/* Poll for events, and handle the ones we care about. */
SDL_Event event;
while (SDL_PollEvent (&event)) {
switch (event.type) {
case SDL_KEYDOWN:
print_key (&event);
break;
case SDL_KEYUP:
print_key (&event);
/* If escape is pressed, return (and thus, quit) */
if (event.key.keysym.sym == SDLK_ESCAPE)
return 0;
break;
case SDL_QUIT:
return (0);
}
}
}
return 0;
}
bool add_keys_from_file(const char *key_file)
{
int size;
FILE *fd = fopen(key_file, "r");
if(fd == NULL)
{
if(g_debug)
perror("cannot open key file");
return false;
}
fseek(fd, 0, SEEK_END);
size = ftell(fd);
fseek(fd, 0, SEEK_SET);
char *buf = xmalloc(size + 1);
if(fread(buf, 1, size, fd) != (size_t)size)
{
if(g_debug)
perror("Cannot read key file");
fclose(fd);
return false;
}
buf[size] = 0;
fclose(fd);
if(g_debug)
printf("Parsing key file '%s'...\n", key_file);
char *p = buf;
while(1)
{
struct crypto_key_t k;
/* parse key */
if(!parse_key(&p, &k))
{
if(g_debug)
printf("invalid key file\n");
return false;
}
if(g_debug)
{
printf("Add key: ");
print_key(&k, true);
}
add_keys(&k, 1);
/* request at least one space character before next key, or end of file */
if(*p != 0 && !isspace(*p))
{
if(g_debug)
printf("invalid key file\n");
return false;
}
/* skip whitespace */
while(isspace(*p))
p++;
if(*p == 0)
break;
}
free(buf);
return true;
}
/*
* Routine:
* Purpose:
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int
pr_s_division(void *pSrc)
{
struct S_DIVISION_TBL *r;
if (pSrc == NULL)
r = &g_s_division;
else
r = pSrc;
print_start(S_DIVISION);
print_key(S_DIVISION_ID, r->id, 1);
print_varchar(S_DIVISION_NAME, r->name, 1);
print_key(S_DIVISION_COMPANY, r->company, 1);
print_end(S_DIVISION);
return(0);
}
/*
* Display all key data.
*/
static void
print_keydata(kdbe_key_t *keys, unsigned int len)
{
unsigned int i;
for (i = 0; i < len; i++, keys++) {
print_key(keys);
}
}
/*
* Routine:
* Purpose:
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int
pr_s_class(void *pSrc)
{
struct S_CLASS_TBL *r;
if (pSrc == NULL)
r = &g_s_class;
else
r = pSrc;
print_start(S_CLASS);
print_key(S_CLASS_ID, r->id, 1);
print_key(S_CLASS_SUBCAT_ID, r->subcat_id, 1);
print_varchar(S_CLASS_DESC, r->desc, 0);
print_end(S_CLASS);
return(0);
}
int capture_input(UINT msg,WPARAM wparam,LPARAM lparam)
{
print_msg(msg,lparam,wparam);
//printf("msg=%08X lp=%08X wp=%08X\n",msg->message,msg->lParam,msg->wParam);
switch(msg){
case WM_LBUTTONDOWN:
{
RECT r;
WORD x,y;
GetWindowRect(get_control_handle(ID_STOP),&r);
x=LOWORD(lparam);y=HIWORD(lparam);
if((x>=0 && y>=0) && (x<(r.right-r.left) && y<(r.bottom-r.top))){
SendMessage(get_control_handle(ID_RECORDED),WM_SETTEXT,0,(LPARAM)"nothing");
SendMessage(get_control_handle(ID_STOP),BM_CLICK,0,0);
}
else{
save_input(pressed_keys,VK_LBUTTON);
process_capture();
}
}
break;
case WM_RBUTTONDOWN:
save_input(pressed_keys,VK_RBUTTON);
process_capture();
break;
case WM_MBUTTONDOWN:
save_input(pressed_keys,VK_MBUTTON);
process_capture();
break;
case WM_LBUTTONUP:
case WM_RBUTTONUP:
case WM_MBUTTONUP:
record_mode=FALSE;
SendMessage(get_control_handle(ID_STOP),BM_CLICK,0,0);
break;
case WM_SYSKEYDOWN:
save_input(pressed_keys,wparam);
process_capture();
print_key(wparam);
break;
case WM_SYSKEYUP:
record_mode=FALSE;
SendMessage(get_control_handle(ID_STOP),BM_CLICK,0,0);
break;
case WM_KEYFIRST:
save_input(pressed_keys,wparam);
process_capture();
break;
case WM_KEYUP:
record_mode=FALSE;
SendMessage(get_control_handle(ID_STOP),BM_CLICK,0,0);
break;
default:
break;
}
}
/*
* Routine:
* Purpose:
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int
pr_s_catalog_promotional_item(void *pSrc)
{
struct S_CATALOG_PROMOTIONAL_ITEM_TBL *r;
if (pSrc == NULL)
r = &g_s_catalog_promotional_item;
else
r = pSrc;
print_start(S_CATALOG_PROMOTIONAL_ITEM);
print_key(S_CATALOG_PROMOTIONAL_ITEM_CATALOG_NUMBER, r->catalog_promotional_item_catalog_number, 1);
print_key(S_CATALOG_PROMOTIONAL_ITEM_CATALOG_PAGE_NUMBER, r->catalog_promotional_item_catalog_page_number, 1);
print_key(S_CATALOG_PROMOTIONAL_ITEM_ITEM_ID, r->catalog_promotional_item_item_id, 1);
print_key(S_CATALOG_PROMOTIONAL_ITEM_PROMOTION_ID, r->catalog_promotional_item_promotion_id, 0);
print_end(S_CATALOG_PROMOTIONAL_ITEM);
return(0);
}
int main(int argc, char **argv)
{
uint8_t key[10];
char ascii[20];
generate_key(key);
fix_key(key);
print_key(ascii, key);
printf("%s\n", ascii);
return 0;
}
void search_hash(node_p hash_array[], unsigned int coo_number)
{
int pos = 0;
int key = hash_key1(coo_number);
int step = hash_key2(coo_number);
pos = key;
while ((hash_array[pos] == NULL) || !print_key(hash_array[pos], coo_number)) {
pos = (pos + step) % MAX_LIMIT;
}
}
/*
=item C<void print_target(lexer_state * const lexer, target * const t)>
Print the target C<t>; if C<t> has a key, that key is
printed as well. Examples:
S1, P1[42]
=cut
*/
void
print_target(ARGIN(lexer_state * const lexer), ARGIN(target * const t))
{
ASSERT_ARGS(print_target)
PARROT_ASSERT(t->info);
fprintf(out, "%c%d", pir_register_types[t->info->type], t->info->color);
/* if the target has a key, print that too */
if (t->key)
print_key(lexer, t->key);
}
/*
* Recursively dump a registry node
* Each key can have a number of subkeys and a number of values
*/
static int
print_registry(char *pkeyname)
{
int i, err;
HKEY key;
char *keyname, *subkeypos;
DWORD keynamelen;
DWORD skeynamelen, oskeynamelen;
LONG ret;
if ((ret = RegOpenKeyEx(rootkey, pkeyname, 0, KEY_READ, &key)) != ERROR_SUCCESS) {
wperror(pkeyname, ret);
return (-1);
}
print_key(key, pkeyname);
if ((ret = RegQueryInfoKey(key, NULL, NULL, NULL,
NULL, &skeynamelen, NULL,
NULL,
NULL, NULL, NULL, NULL)) != ERROR_SUCCESS) {
wperror("RegQueryInfoKey", ret);
RegCloseKey(key);
return (-1);
}
skeynamelen++;
if (pkeyname)
keynamelen = skeynamelen + strlen(pkeyname) + 1; /* To hold the \ */
else
keynamelen = skeynamelen;
subkeypos = keyname = malloc(keynamelen);
if (pkeyname) {
strcpy(keyname, pkeyname);
strcat(keyname, "\\");
subkeypos += strlen(pkeyname) + 1;
}
for (i = 0; ; i++) {
oskeynamelen = skeynamelen;
switch (err = RegEnumKeyEx(key, i, subkeypos, &oskeynamelen, NULL, NULL, NULL, NULL)) {
case ERROR_SUCCESS:
print_registry(keyname);
break;
case ERROR_NO_MORE_ITEMS:
RegCloseKey(key);
free(keyname);
return (0);
default:
wperror("RegEnumKeyEx", err);
RegCloseKey(key);
free(keyname);
return (-1);
}
}
/* NOTREACHED */
}
void read_pedals() {
int r = 0, i = 0;
unsigned char query[8] = {0x01, 0x82, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00};
unsigned char response[8];
for (i = 0 ; i < 3 ; i++) {
query[3] = i + 1;
usb_write(query);
r = hid_read(dev, response, 8);
if (r < 0) {
fatal("error reading data (%ls)", hid_error(dev));
}
printf("[switch %d]: ", i + 1);
switch (response[1]) {
case 0:
printf("unconfigured");
break;
case 1:
case 0x81:
print_key(response);
break;
case 2:
print_mouse(response);
break;
case 3:
print_key(response);
printf(" ");
print_mouse(response);
break;
case 4:
print_string(response);
break;
default:
fprintf(stderr, "Unknown response:\n");
debug_arr(response, 8);
return;
}
printf("\n");
}
}
/*
* Routine:
* Purpose:
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int
pr_w_store_sales(void *row)
{
struct W_STORE_SALES_TBL *r;
if (row == NULL)
r = &g_w_store_sales;
else
r = row;
print_start(STORE_SALES);
print_key(SS_SOLD_DATE_SK, r->ss_sold_date_sk, 1);
print_key(SS_SOLD_TIME_SK, r->ss_sold_time_sk, 1);
print_key(SS_SOLD_ITEM_SK, r->ss_sold_item_sk, 1);
print_key(SS_SOLD_CUSTOMER_SK, r->ss_sold_customer_sk, 1);
print_key(SS_SOLD_CDEMO_SK, r->ss_sold_cdemo_sk, 1);
print_key(SS_SOLD_HDEMO_SK, r->ss_sold_hdemo_sk, 1);
print_key(SS_SOLD_ADDR_SK, r->ss_sold_addr_sk, 1);
print_key(SS_SOLD_STORE_SK, r->ss_sold_store_sk, 1);
print_key(SS_SOLD_PROMO_SK, r->ss_sold_promo_sk, 1);
print_key(SS_TICKET_NUMBER, r->ss_ticket_number, 1);
print_integer(SS_PRICING_QUANTITY, r->ss_pricing.quantity, 1);
print_decimal(SS_PRICING_WHOLESALE_COST, &r->ss_pricing.wholesale_cost, 1);
print_decimal(SS_PRICING_LIST_PRICE, &r->ss_pricing.list_price, 1);
print_decimal(SS_PRICING_SALES_PRICE, &r->ss_pricing.sales_price, 1);
print_decimal(SS_PRICING_COUPON_AMT, &r->ss_pricing.coupon_amt, 1);
print_decimal(SS_PRICING_EXT_SALES_PRICE, &r->ss_pricing.ext_sales_price, 1);
print_decimal(SS_PRICING_EXT_WHOLESALE_COST, &r->ss_pricing.ext_wholesale_cost, 1);
print_decimal(SS_PRICING_EXT_LIST_PRICE, &r->ss_pricing.ext_list_price, 1);
print_decimal(SS_PRICING_EXT_TAX, &r->ss_pricing.ext_tax, 1);
print_decimal(SS_PRICING_COUPON_AMT, &r->ss_pricing.coupon_amt, 1);
print_decimal(SS_PRICING_NET_PAID, &r->ss_pricing.net_paid, 1);
print_decimal(SS_PRICING_NET_PAID_INC_TAX, &r->ss_pricing.net_paid_inc_tax, 1);
print_decimal(SS_PRICING_NET_PROFIT, &r->ss_pricing.net_profit, 0);
print_end(STORE_SALES);
return(0);
}
int main(int argc, char const *argv[])
{
char pre_puzzle_key[16];
char secret_key[16];
uint32_t inv[4]={0,0,0,0};
char puzzle_key[4];
for (int i = 0; i < 5; ++i)
{
//initialise seed value
srand(time(0)+i);
//get pair of secret string
get_key(pre_puzzle_key,secret_key);
//print key
print_key(pre_puzzle_key);
print_key(secret_key);
cMD4(inv,(uint32_t*)pre_puzzle_key,(uint32_t*)puzzle_key);
}
return 0;
}
