/** Add entropy to the PRNG state @param in The data to add @param inlen Length of the data to add @param prng PRNG state to update @return CRYPT_OK if successful */ int sober128_add_entropy(const unsigned char *in, unsigned long inlen, prng_state *prng) { struct sober128_prng *c; ulong32 i, k; LTC_ARGCHK(in != NULL); LTC_ARGCHK(prng != NULL); c = &(prng->sober128); if (c->flag == 1) { /* this is the first call to the add_entropy so this input is the key */ /* inlen must be multiple of 4 bytes */ if ((inlen & 3) != 0) { return CRYPT_INVALID_KEYSIZE; } for (i = 0; i < inlen; i += 4) { k = BYTE2WORD((unsigned char *)&in[i]); ADDKEY(k); cycle(c->R); XORNL(nltap(c)); } /* also fold in the length of the key */ ADDKEY(inlen); /* now diffuse */ s128_diffuse(c); s128_genkonst(c); s128_savestate(c); c->nbuf = 0; c->flag = 0; c->set = 1; } else { /* ok we are adding an IV then... */ s128_reloadstate(c); /* inlen must be multiple of 4 bytes */ if ((inlen & 3) != 0) { return CRYPT_INVALID_KEYSIZE; } for (i = 0; i < inlen; i += 4) { k = BYTE2WORD((unsigned char *)&in[i]); ADDKEY(k); cycle(c->R); XORNL(nltap(c)); } /* also fold in the length of the key */ ADDKEY(inlen); /* now diffuse */ s128_diffuse(c); c->nbuf = 0; } return CRYPT_OK; }
/** Set IV to the Sober128 state @param c The Sober12820 state @param iv The IV data to add @param ivlen The length of the IV (must be 12) @return CRYPT_OK on success */ int sober128_stream_setiv(sober128_state *c, const unsigned char *iv, unsigned long ivlen) { ulong32 i, k; LTC_ARGCHK(c != NULL); LTC_ARGCHK(iv != NULL); LTC_ARGCHK(ivlen > 0); /* ok we are adding an IV then... */ s128_reloadstate(c); /* ivlen must be multiple of 4 bytes */ if ((ivlen & 3) != 0) { return CRYPT_INVALID_KEYSIZE; } for (i = 0; i < ivlen; i += 4) { k = BYTE2WORD((unsigned char *)&iv[i]); ADDKEY(k); cycle(c->R); XORNL(nltap(c)); } /* also fold in the length of the key */ ADDKEY(ivlen); /* now diffuse */ s128_diffuse(c); c->nbuf = 0; return CRYPT_OK; }
int sober128_add_entropy(const unsigned char *buf, unsigned long len, prng_state *prng) { struct sober128_prng *c; ulong32 i, k; c = &(prng->sober128); if (c->flag == 1) { /* this is the first call to the add_entropy so this input is the key */ /* len must be multiple of 4 bytes */ assert ((len & 3) == 0); for (i = 0; i < len; i += 4) { k = BYTE2WORD(&buf[i]); ADDKEY(k); cycle(c->R); XORNL(nltap(c)); } /* also fold in the length of the key */ ADDKEY(len); /* now diffuse */ s128_diffuse(c); s128_genkonst(c); s128_savestate(c); c->nbuf = 0; c->flag = 0; c->set = 1; } else { /* ok we are adding an IV then... */ s128_reloadstate(c); /* len must be multiple of 4 bytes */ assert ((len & 3) == 0); for (i = 0; i < len; i += 4) { k = BYTE2WORD(&buf[i]); ADDKEY(k); cycle(c->R); XORNL(nltap(c)); } /* also fold in the length of the key */ ADDKEY(len); /* now diffuse */ s128_diffuse(c); c->nbuf = 0; } return CRYPT_OK; }
/* Having accumulated a MAC, finish processing and return it */ void s128_finish(s128_ctx *c, UCHAR *buf, int nbytes) { UCHAR *endbuf; WORD t = 0; if ((nbytes & 3) != 0) abort(); /* perturb the state to mark end of input -- sort of like adding more key */ ADDKEY(INITKONST); cycle(c->R); XORNL(nltap(c)); s128_diffuse(c); /* don't bother optimising this loop, because it's a state * of delusion to generate more than N words of MAC. */ endbuf = &buf[nbytes]; while (buf < endbuf) { cycle(c->R); t = nltap(c); WORD2BYTE(t, buf); buf += 4; } }
/** Initialize an Sober128 context (only the key) @param c [out] The destination of the Sober128 state @param key The secret key @param keylen The length of the secret key (octets) @return CRYPT_OK if successful */ int sober128_stream_setup(sober128_state *c, const unsigned char *key, unsigned long keylen) { ulong32 i, k; LTC_ARGCHK(c != NULL); LTC_ARGCHK(key != NULL); LTC_ARGCHK(keylen > 0); /* keylen must be multiple of 4 bytes */ if ((keylen & 3) != 0) { return CRYPT_INVALID_KEYSIZE; } /* Register initialised to Fibonacci numbers */ c->R[0] = 1; c->R[1] = 1; for (i = 2; i < N; ++i) { c->R[i] = c->R[i-1] + c->R[i-2]; } c->konst = INITKONST; for (i = 0; i < keylen; i += 4) { k = BYTE2WORD((unsigned char *)&key[i]); ADDKEY(k); cycle(c->R); XORNL(nltap(c)); } /* also fold in the length of the key */ ADDKEY(keylen); /* now diffuse */ s128_diffuse(c); s128_genkonst(c); s128_savestate(c); c->nbuf = 0; return CRYPT_OK; }
static void s128_loadkey(s128_ctx *c, UCHAR key[], int keylen) { int i; WORD k; /* start folding in key, reject odd sized keys */ if ((keylen & 3) != 0) abort(); for (i = 0; i < keylen; i += 4) { k = BYTE2WORD(&key[i]); ADDKEY(k); cycle(c->R); XORNL(nltap(c)); } /* also fold in the length of the key */ ADDKEY(keylen); /* now diffuse */ s128_diffuse(c); }
void ukbd_decode(struct ukbd_softc *sc, struct ukbd_data *ud) { int mod, omod; u_int16_t ibuf[MAXKEYS]; /* chars events */ int s; int nkeys, i, j; int key; #define ADDKEY(c) ibuf[nkeys++] = (c) #ifdef UKBD_DEBUG /* * Keep a trace of the last events. Using printf changes the * timing, so this can be useful sometimes. */ if (ukbdtrace) { struct ukbdtraceinfo *p = &ukbdtracedata[ukbdtraceindex]; p->unit = sc->sc_hdev.sc_dev.dv_unit; microtime(&p->tv); p->ud = *ud; if (++ukbdtraceindex >= UKBDTRACESIZE) ukbdtraceindex = 0; } if (ukbddebug > 5) { struct timeval tv; microtime(&tv); DPRINTF((" at %lu.%06lu mod=0x%02x key0=0x%02x key1=0x%02x " "key2=0x%02x key3=0x%02x\n", tv.tv_sec, tv.tv_usec, ud->modifiers, ud->keycode[0], ud->keycode[1], ud->keycode[2], ud->keycode[3])); } #endif if (ud->keycode[0] == KEY_ERROR) { DPRINTF(("ukbd_intr: KEY_ERROR\n")); return; /* ignore */ } nkeys = 0; mod = ud->modifiers; omod = sc->sc_odata.modifiers; if (mod != omod) for (i = 0; i < sc->sc_nmod; i++) if (( mod & sc->sc_mods[i].mask) != (omod & sc->sc_mods[i].mask)) ADDKEY(sc->sc_mods[i].key | (mod & sc->sc_mods[i].mask ? PRESS : RELEASE)); if (memcmp(ud->keycode, sc->sc_odata.keycode, sc->sc_nkeycode) != 0) { /* Check for released keys. */ for (i = 0; i < sc->sc_nkeycode; i++) { key = sc->sc_odata.keycode[i]; if (key == 0) continue; for (j = 0; j < sc->sc_nkeycode; j++) if (key == ud->keycode[j]) goto rfound; DPRINTFN(3,("ukbd_intr: relse key=0x%02x\n", key)); ADDKEY(key | RELEASE); rfound: ; } /* Check for pressed keys. */ for (i = 0; i < sc->sc_nkeycode; i++) { key = ud->keycode[i]; if (key == 0) continue; for (j = 0; j < sc->sc_nkeycode; j++) if (key == sc->sc_odata.keycode[j]) goto pfound; DPRINTFN(2,("ukbd_intr: press key=0x%02x\n", key)); ADDKEY(key | PRESS); pfound: ; } } sc->sc_odata = *ud; if (nkeys == 0) return; if (sc->sc_polling) { DPRINTFN(1,("ukbd_intr: pollchar = 0x%03x\n", ibuf[0])); memcpy(sc->sc_pollchars, ibuf, nkeys * sizeof(u_int16_t)); sc->sc_npollchar = nkeys; return; } #ifdef WSDISPLAY_COMPAT_RAWKBD if (sc->sc_rawkbd) { u_char cbuf[MAXKEYS * 2]; int c; int npress; for (npress = i = j = 0; i < nkeys; i++) { key = ibuf[i]; c = ukbd_trtab[key & CODEMASK]; if (c == NN) continue; if (c & 0x80) cbuf[j++] = 0xe0; cbuf[j] = c & 0x7f; if (key & RELEASE) cbuf[j] |= 0x80; else { /* remember pressed keys for autorepeat */ if (c & 0x80) sc->sc_rep[npress++] = 0xe0; sc->sc_rep[npress++] = c & 0x7f; } DPRINTFN(1,("ukbd_intr: raw = %s0x%02x\n", c & 0x80 ? "0xe0 " : "", cbuf[j])); j++; } s = spltty(); wskbd_rawinput(sc->sc_wskbddev, cbuf, j); splx(s); if (npress != 0) { sc->sc_nrep = npress; timeout_add(&sc->sc_rawrepeat_ch, hz * REP_DELAY1 / 1000); } else timeout_del(&sc->sc_rawrepeat_ch); return; } #endif s = spltty(); for (i = 0; i < nkeys; i++) { key = ibuf[i]; wskbd_input(sc->sc_wskbddev, key&RELEASE ? WSCONS_EVENT_KEY_UP : WSCONS_EVENT_KEY_DOWN, key&CODEMASK); } splx(s); }
bool StringKeyToHKey(LPCWSTR asKey, HKEY* phkey) { static struct {LPCWSTR pszKey; LPCWSTR pszAlias; HKEY hk;} pRootKeys[10]; // HKEY__HIVE_NAME_LWR, HKEY_CLASSES_ROOT..HKEY_CURRENT_USER_LOCAL_SETTINGS static int nRootKeysFilled; if (!nRootKeysFilled) { int k = 0; #define ADDKEY(key,alias,hkey) \ pRootKeys[k].pszKey = key; pRootKeys[k].pszAlias = alias; pRootKeys[k++].hk = hkey; ADDKEY(HKEY__HIVE_NAME_LWR, NULL, HKEY__HIVE); ADDKEY(L"hkey_current_user", L"hkcu", HKEY_CURRENT_USER); ADDKEY(L"hkey_classes_root", L"hkcr", HKEY_CLASSES_ROOT); ADDKEY(L"hkey_local_machine", L"hklm", HKEY_LOCAL_MACHINE); ADDKEY(L"hkey_users", L"hku", HKEY_USERS); ADDKEY(L"hkey_performance_data", NULL, HKEY_PERFORMANCE_DATA); ADDKEY(L"hkey_current_config", NULL, HKEY_CURRENT_CONFIG); ADDKEY(L"hkey_dyn_data", NULL, HKEY_DYN_DATA); ADDKEY(L"hkey_current_user_local_settings", NULL, HKEY_CURRENT_USER_LOCAL_SETTINGS); nRootKeysFilled = k; } _ASSERTE(pRootKeys[0].pszKey[0]!=0); #define CHK(i,c) ( (asKey[i] == (WORD)c) || (asKey[i]|0x20) == (WORD)c ) if (!CHK(0,'h') || !CHK(1,'k')) return false; for (int k = 0; k < nRootKeysFilled; k++) { bool bMatch = true; int c = 2; while (asKey[c]) { if (!CHK(c, pRootKeys[k].pszKey[c])) { bMatch = false; break; } c++; } if (bMatch && pRootKeys[k].pszKey[c] == 0) { if (phkey) *phkey = pRootKeys[k].hk; return true; } // Alias if (pRootKeys[k].pszAlias) { bMatch = true; c = 2; while (asKey[c]) { if (!CHK(c, pRootKeys[k].pszAlias[c])) { bMatch = false; break; } c++; } if (bMatch && pRootKeys[k].pszAlias[c] == 0) { if (phkey) *phkey = pRootKeys[k].hk; return true; } } } return false; //if (!lstrcmpiW(asKey, L"HKCR") || !lstrcmpiW(asKey, L"HKEY_CLASSES_ROOT")) { // if (phkey) *phkey = HKEY_CLASSES_ROOT; //} else //if (!lstrcmpiW(asKey, L"HKCU") || !lstrcmpiW(asKey, L"HKEY_CURRENT_USER")) { // if (phkey) *phkey = HKEY_CURRENT_USER; //} else //if (!lstrcmpiW(asKey, L"HKLM") || !lstrcmpiW(asKey, L"HKEY_LOCAL_MACHINE")) { // if (phkey) *phkey = HKEY_LOCAL_MACHINE; //} else //if (!lstrcmpiW(asKey, L"HKU") || !lstrcmpiW(asKey, L"HKEY_USERS")) { // if (phkey) *phkey = HKEY_USERS; //} else //if (!lstrcmpiW(asKey, L"HKCC") || !lstrcmpiW(asKey, L"HKEY_CURRENT_CONFIG")) { // if (phkey) *phkey = HKEY_CURRENT_CONFIG; //} else //if (!lstrcmpiW(asKey, L"HKEY_PERFORMANCE_DATA")) { // if (phkey) *phkey = HKEY_PERFORMANCE_DATA; //} else //if (!lstrcmpiW(asKey, HKEY__HIVE_NAME)) { // if (phkey) *phkey = HKEY__HIVE; //} else { // return false; //} //return true; }
static void btkbd_input(struct bthidev *hidev, uint8_t *data, int len) { struct btkbd_softc *sc = (struct btkbd_softc *)hidev; struct btkbd_data *ud = &sc->sc_ndata; uint16_t ibuf[MAXKEYS]; uint32_t mod, omod; int nkeys, i, j; int key; int s; if (sc->sc_wskbd == NULL || sc->sc_enabled == 0) return; /* extract key modifiers */ ud->modifiers = 0; for (i = 0 ; i < sc->sc_nmod ; i++) if (hid_get_data(data, &sc->sc_modloc[i])) ud->modifiers |= sc->sc_mods[i].mask; /* extract keycodes */ memcpy(ud->keycode, data + (sc->sc_keycodeloc.pos / 8), sc->sc_nkeycode); if (ud->keycode[0] == KEY_ERROR) return; /* ignore */ nkeys = 0; mod = ud->modifiers; omod = sc->sc_odata.modifiers; if (mod != omod) for (i = 0 ; i < sc->sc_nmod ; i++) if ((mod & sc->sc_mods[i].mask) != (omod & sc->sc_mods[i].mask)) ADDKEY(sc->sc_mods[i].key | (mod & sc->sc_mods[i].mask ? PRESS : RELEASE)); if (memcmp(ud->keycode, sc->sc_odata.keycode, sc->sc_nkeycode) != 0) { /* Check for released keys. */ for (i = 0 ; i < sc->sc_nkeycode ; i++) { key = sc->sc_odata.keycode[i]; if (key == 0) continue; for (j = 0 ; j < sc->sc_nkeycode ; j++) if (key == ud->keycode[j]) goto rfound; ADDKEY(key | RELEASE); rfound: ; } /* Check for pressed keys. */ for (i = 0 ; i < sc->sc_nkeycode ; i++) { key = ud->keycode[i]; if (key == 0) continue; for (j = 0; j < sc->sc_nkeycode; j++) if (key == sc->sc_odata.keycode[j]) goto pfound; ADDKEY(key | PRESS); pfound: ; } } sc->sc_odata = *ud; if (nkeys == 0) return; #ifdef WSDISPLAY_COMPAT_RAWKBD if (sc->sc_rawkbd) { u_char cbuf[MAXKEYS * 2]; int c; int npress; for (npress = i = j = 0 ; i < nkeys ; i++) { key = ibuf[i]; c = btkbd_trtab[key & CODEMASK]; if (c == NN) continue; if (c & 0x80) cbuf[j++] = 0xe0; cbuf[j] = c & 0x7f; if (key & RELEASE) cbuf[j] |= 0x80; #ifdef BTKBD_REPEAT else { /* remember pressed keys for autorepeat */ if (c & 0x80) sc->sc_rep[npress++] = 0xe0; sc->sc_rep[npress++] = c & 0x7f; } #endif j++; } s = spltty(); wskbd_rawinput(sc->sc_wskbd, cbuf, j); splx(s); #ifdef BTKBD_REPEAT callout_stop(&sc->sc_repeat); if (npress != 0) { sc->sc_nrep = npress; callout_schedule(&sc->sc_repeat, hz * REP_DELAY1 / 1000); } #endif return; } #endif s = spltty(); for (i = 0 ; i < nkeys ; i++) { key = ibuf[i]; wskbd_input(sc->sc_wskbd, key & RELEASE ? WSCONS_EVENT_KEY_UP : WSCONS_EVENT_KEY_DOWN, key & CODEMASK); } splx(s); }
KeyMap::KeyMap(){ #define ADDKEY(KeyName) Keys[sf::Key::KeyName]=#KeyName;Names[#KeyName]=sf::Key::KeyName ADDKEY(A); ADDKEY(B); ADDKEY(C); ADDKEY(D); ADDKEY(E); ADDKEY(F); ADDKEY(G); ADDKEY(H); ADDKEY(I); ADDKEY(J); ADDKEY(K); ADDKEY(L); ADDKEY(M); ADDKEY(N); ADDKEY(O); ADDKEY(P); ADDKEY(Q); ADDKEY(R); ADDKEY(S); ADDKEY(T); ADDKEY(U); ADDKEY(V); ADDKEY(W); ADDKEY(X); ADDKEY(Y); ADDKEY(Z); ADDKEY(Num0); ADDKEY(Num1); ADDKEY(Num2); ADDKEY(Num3); ADDKEY(Num4); ADDKEY(Num5); ADDKEY(Num6); ADDKEY(Num7); ADDKEY(Num8); ADDKEY(Num9); ADDKEY(Escape); ADDKEY(LControl); ADDKEY(LShift); ADDKEY(LAlt); ADDKEY(LSystem); ADDKEY(RControl); ADDKEY(RShift); ADDKEY(RAlt); ADDKEY(RSystem); ADDKEY(Menu); ADDKEY(LBracket); ADDKEY(RBracket); ADDKEY(SemiColon); ADDKEY(Comma); ADDKEY(Period); ADDKEY(Quote); ADDKEY(Slash); ADDKEY(BackSlash); ADDKEY(Tilde); ADDKEY(Equal); ADDKEY(Dash); ADDKEY(Space); ADDKEY(Return); ADDKEY(Back); ADDKEY(Tab); ADDKEY(PageUp); ADDKEY(PageDown); ADDKEY(End); ADDKEY(Home); ADDKEY(Insert); ADDKEY(Delete); ADDKEY(Add); ADDKEY(Subtract); ADDKEY(Multiply); ADDKEY(Divide); ADDKEY(Left); ADDKEY(Right); ADDKEY(Up); ADDKEY(Down); ADDKEY(Numpad0); ADDKEY(Numpad1); ADDKEY(Numpad2); ADDKEY(Numpad3); ADDKEY(Numpad4); ADDKEY(Numpad5); ADDKEY(Numpad6); ADDKEY(Numpad7); ADDKEY(Numpad8); ADDKEY(Numpad9); ADDKEY(F1); ADDKEY(F2); ADDKEY(F3); ADDKEY(F4); ADDKEY(F5); ADDKEY(F6); ADDKEY(F7); ADDKEY(F8); ADDKEY(F9); ADDKEY(F10); ADDKEY(F11); ADDKEY(F12); ADDKEY(F13); ADDKEY(F14); ADDKEY(F15); ADDKEY(Pause); #undef ADDKEY }