bool rsa_ssh1_encrypt(unsigned char *data, int length, RSAKey *key) { mp_int *b1, *b2; int i; unsigned char *p; if (key->bytes < length + 4) return false; /* RSA key too short! */ memmove(data + key->bytes - length, data, length); data[0] = 0; data[1] = 2; size_t npad = key->bytes - length - 3; /* * Generate a sequence of nonzero padding bytes. We do this in a * reasonably uniform way and without having to loop round * retrying the random number generation, by first generating an * integer in [0,2^n) for an appropriately large n; then we * repeatedly multiply by 255 to give an integer in [0,255*2^n), * extract the top 8 bits to give an integer in [0,255), and mask * those bits off before multiplying up again for the next digit. * This gives us a sequence of numbers in [0,255), and of course * adding 1 to each of them gives numbers in [1,256) as we wanted. * * (You could imagine this being a sort of fixed-point operation: * given a uniformly random binary _fraction_, multiplying it by k * and subtracting off the integer part will yield you a sequence * of integers each in [0,k). I'm just doing that scaled up by a * power of 2 to avoid the fractions.) */ size_t random_bits = (npad + 16) * 8; mp_int *randval = mp_new(random_bits + 8); mp_int *tmp = mp_random_bits(random_bits); mp_copy_into(randval, tmp); mp_free(tmp); for (i = 2; i < key->bytes - length - 1; i++) { mp_mul_integer_into(randval, randval, 255); uint8_t byte = mp_get_byte(randval, random_bits / 8); assert(byte != 255); data[i] = byte + 1; mp_reduce_mod_2to(randval, random_bits); } mp_free(randval); data[key->bytes - length - 1] = 0; b1 = mp_from_bytes_be(make_ptrlen(data, key->bytes)); b2 = mp_modpow(b1, key->exponent, key->modulus); p = data; for (i = key->bytes; i--;) { *p++ = mp_get_byte(b2, i); } mp_free(b1); mp_free(b2); return true; }
void mpi_init_size(mpi *p, mp_size size) { if (size == 0) size = 1; p->digits = mp_new(size); p->alloc = size; p->size = 0; p->sign = 0; }
struct hotplug * hotplug_init(void) { struct mempool *mp = mp_new(CPU_PAGE_SIZE); struct hotplug *hp = mp_alloc_zero(mp, sizeof(*hp)); hp->mp = mp; sys_dbg("hotplug init"); plugable_usb_init(hp); return hp; }
void mm_ctx_mempool(knot_mm_t *mm, size_t chunk_size) { mm->ctx = mp_new(chunk_size); mm->alloc = (knot_mm_alloc_t)mp_alloc; mm->free = mm_nofree; }
int main(int argc, char *argv[]) { plan(11); /* Create memory pool context. */ struct mempool *pool = mp_new(64 * 1024); knot_mm_t mm; mm.ctx = pool; mm.alloc = (knot_mm_alloc_t)mp_alloc; mm.free = NULL; /* Create hashtable */ int ret = KNOT_EOK; uint16_t len = 0; const char *key = "mykey", *cur = NULL, *prev = NULL; value_t val = (void*)0xdeadbeef, *rval = NULL; hhash_iter_t it; hhash_t *tbl = hhash_create_mm(ELEM_COUNT, &mm); ok(tbl != NULL, "hhash: create"); if (tbl == NULL) { return KNOT_ERROR; /* No point in testing further on. */ } /* Generate random keys. */ char *keys[ELEM_COUNT]; unsigned nfilled = 0; for (unsigned i = 0; i < ELEM_COUNT; ++i) { keys[i] = test_randstr_mm(&mm); } /* Insert single element. */ ret = hhash_insert(tbl, key, KEY_LEN(key), val); ok(ret == KNOT_EOK, "hhash: insert single element"); /* Retrieve nonexistent element. */ cur = "nokey"; rval = hhash_find(tbl, cur, KEY_LEN(cur)); ok(rval == NULL, "hhash: find non-existent element"); /* Retrieve single element. */ rval = hhash_find(tbl, key, KEY_LEN(key)); ok(rval != NULL, "hhash: find existing element"); /* Fill the table. */ for (unsigned i = 0; i < ELEM_COUNT; ++i) { ret = hhash_insert(tbl, keys[i], KEY_LEN(keys[i]), keys[i]); if (ret != KNOT_EOK) { nfilled = i; break; } } /* Check all keys integrity. */ unsigned nfound = 0; for (unsigned i = 0; i < nfilled; ++i) { rval = hhash_find(tbl, keys[i], KEY_LEN(keys[i])); if (!rval || memcmp(*rval, keys[i], KEY_LEN(keys[i])) != 0) { break; /* Mismatch */ } ++nfound; } is_int(nfilled, nfound, "hhash: found all inserted keys"); /* Test keys order index. */ hhash_build_index(tbl); hhash_iter_begin(tbl, &it, true); while (!hhash_iter_finished(&it)) { cur = hhash_iter_key(&it, &len); if (!str_check_sort(prev, cur)) { break; } prev = cur; int strl = strlen(cur); assert(strl + 1 == len); hhash_iter_next(&it); } ok(hhash_iter_finished(&it), "hhash: passed order index checks"); /* Retrieve all keys. */ nfound = 0; hhash_iter_begin(tbl, &it, false); while (!hhash_iter_finished(&it)) { cur = hhash_iter_key(&it, &len); if (hhash_find(tbl, cur, len) == NULL) { break; } else { ++nfound; } hhash_iter_next(&it); } ok(hhash_iter_finished(&it), "hhash: found all iterated keys"); is_int(tbl->weight, nfound, "hhash: all iterated keys found"); /* Test find less or equal. */ prev = "mykey0"; /* mykey should precede it */ hhash_find_leq(tbl, prev, KEY_LEN(prev), &rval); ok(rval && *rval == val, "hhash: find less or equal"); /* Delete key and retrieve it. */ ret = hhash_del(tbl, key, KEY_LEN(key)); ok(ret == KNOT_EOK, "hhash: remove key"); rval = hhash_find(tbl, key, KEY_LEN(key)); ok(rval == NULL, "hhash: find removed element"); /* Free all memory. */ mp_delete(mm.ctx); return KNOT_EOK; }