size_t
Any::complexity(bir mults) const
{
const auto bits = bitsize().get();
if (bitsize() < bits) {
return static_cast<size_t>(1) << bits;
} else {
return pnw::maxof<size_t>();
}
}
Values new_public(const uint32_t & L, const uint32_t & N){
// L = 1024, N = 160
// L = 2048, N = 224
// L = 2048, N = 256
// L = 3072, N = 256
RNG::BBS(static_cast <MPI> (static_cast <unsigned int> (now()))); // seed just in case not seeded
// random prime q
MPI q = bintompi("1" + RNG::BBS().rand(N - 1));
q = nextprime(q);
while (bitsize(q) > N){
q = bintompi("1" + RNG::BBS().rand(N - 1));
q = nextprime(q);
}
// random prime p = kq + 1
MPI p = bintompi("1" + RNG::BBS().rand(L - 1)); // pick random starting point
p = ((p - 1) / q) * q + 1; // set starting point to value such that p = kq + 1 for some k, while maintaining bitsize
while (!knuth_prime_test(p, 25)){
p += q;
}
// generator g with order q
MPI g = 1, h = 1;
MPI exp = (p - 1) / q;
while (g == 1){
h++;
g = powm(h, exp, p);
}
return {p, q, g};
}
Values keygen(Values & pub){
RNG::BBS(static_cast <MPI> (static_cast <unsigned int> (now()))); // seed just in case not seeded
MPI x = 0;
std::string test = "testing testing 123"; // a string to test the key with, just in case the key doesn't work for some reason
unsigned int bits = bitsize(pub[1]) - 1;
while (true){
// 0 < x < q
while ((x == 0) || (pub[1] <= x)){
x = bintompi(RNG::BBS().rand(bits));
}
// y = g^x mod p
MPI y;
y = powm(pub[2], x, pub[0]);
// public key = p, q, g, y
// private key = x
pub.push_back(y);
// check that this key works
Values rs = sign(test, {x}, pub);
// if it works, break
if (verify(test, rs, pub)){
break;
}
pub.pop_back();
}
return {x};
}
void increment(uint64_t i, uint64_t delta, bool subtract = false){
assert(i<size_);
//value at position i
auto pvi = at(i);
if(subtract){
assert(pvi>=delta);
set(i,pvi-delta);
}else{
uint64_t s = pvi+delta;
if(bitsize(s)>width_){
//in this case rebuild the whole vector with a new bitsize
rebuild_set( i, s );
}else{
//just increment
set(i,s);
}
}
}
void insert(uint64_t i, uint64_t x){
if(bitsize(x)>width_){
//auto vec = to_vector(i,x);
//rebuild(vec);
rebuild_ins( i, x );
return;
}
//not enough space for the new element:
//alloc extra_ new words
if(size_+1>(words.size()*(int_per_word_))){
//resize words
auto temp = vector<uint64_t>(words.size()+extra_,0);
uint64_t j = 0;
for(auto x:words) temp[j++] = x;
words = vector<uint64_t>(temp);
}
//shift right elements starting from number i
shift_right(i);
//insert x
set(i,x);
++size_;
}
Values sign(const MPI & data, const Values & pri, const Values & pub, MPI k){
RNG::BBS(static_cast <MPI> (static_cast <unsigned int> (now()))); // seed just in case not seeded
bool set_k = (k == 0);
MPI r = 0, s = 0;
while ((r == 0) || (s == 0)){
// 0 < k < q
if ( set_k ) {
k = bintompi(RNG::BBS().rand(bitsize(pub[1])));
k %= pub[1];
}
// r = (g^k mod p) mod q
r = powm(pub[2], k, pub[0]);
r %= pub[1];
// if r == 0, don't bother calculating s
if (r == 0){
continue;
}
// s = k^-1 (m + x * r) mod q
s = invert(k, pub[1]);
s *= data + pri[0] * r;
s %= pub[1];
}
return {r, s};
}
Values encrypt(const MPI & data, const Values & pub){
RNG::BBS(static_cast <MPI> (static_cast <unsigned int> (now()))); // seed just in case not seeded
MPI k = bintompi(RNG::BBS().rand(bitsize(pub[0])));
k %= pub[0];
MPI r, s;
r = powm(pub[1], k, pub[0]);
s = powm(pub[2], k, pub[0]);
return {r, (data * s) % pub[0]};
}
Offsets(uint_t _key_len, uint_t _val_len, uint_t _reprobe_limit) :
key_len(_key_len),
val_len(_val_len),
reprobe_limit(_reprobe_limit),
reprobe_len(bitsize(reprobe_limit)),
lval_len(key_len + val_len - reprobe_len),
block(compute_offsets()),
bld(block.len)
{ }
void init(uint_t _key_len, uint_t _val_len, uint_t _reprobe_limit) {
key_len = _key_len;
val_len = _val_len;
reprobe_limit = _reprobe_limit;
reprobe_len = bitsize(_reprobe_limit);
lval_len = key_len + val_len - reprobe_len;
compute_offsets();
bld = divisor64(block_len);
}
void remove(uint64_t i) {
auto x = this->at(i);
if (width_>1) { // otherwise, cannot rebuild
if (bitsize(x) == width_) {
uint8_t max_b = 0;
for(ulint j = 0; j < size_ ;++j){
if (j != i) {
auto x = this->at(j);
uint8_t bs = bitsize(x);
if(bs>max_b) max_b=bs;
}
}
//rebuild entire vector
rebuild_rem( i, max_b );
return;
}
}
//shift ints left, from position i + 1 onwords
shift_left( i );
while ( (words.size() - extra_ - 1)*(int_per_word_) >= size_ - 1 ) {
//more than extra_ extra words, delete
words.pop_back();
if (words.size() == 0)
break;
}
--size_;
psum_ -= x;
}
END_TEST
START_TEST(test_alphabet)
{
int side;
unsigned char bitdata[QR_MAX_BITDATA];
memset(bitdata, sizeof(bitdata), 0);
side = qr_encode(QR_LEVEL_L, 0, "test", 0, bitdata);
ck_assert_int_eq(side, 21);
ck_assert_int_eq(memcmp(bitdata, RESULT_ALPHA_1, bitsize(side)), 0);
memset(bitdata, sizeof(bitdata), 0);
side = qr_encode(QR_LEVEL_M, 0, "test", 0, bitdata);
ck_assert_int_eq(side, 21);
ck_assert_int_eq(memcmp(bitdata, RESULT_ALPHA_2, bitsize(side)), 0);
memset(bitdata, sizeof(bitdata), 0);
side = qr_encode(QR_LEVEL_Q, 0, "test", 0, bitdata);
ck_assert_int_eq(side, 21);
ck_assert_int_eq(memcmp(bitdata, RESULT_ALPHA_3, bitsize(side)), 0);
memset(bitdata, sizeof(bitdata), 0);
side = qr_encode(QR_LEVEL_H, 0, "test", 0, bitdata);
ck_assert_int_eq(side, 21);
ck_assert_int_eq(memcmp(bitdata, RESULT_ALPHA_4, bitsize(side)), 0);
#if QR_MAX_VERSION >= QR_VERSION_M
const char *lipsum = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras at risus sodales, rhoncus arcu eu, accumsan augue. Mauris a mauris et ante porta eleifend. Sed condimentum metus vitae tortor bibendum, et scelerisque quam placerat. Nam at sapien lacus. Proin magna ipsum, dapibus non dignissim a, posuere vitae nulla. Donec pretium odio sit amet lorem interdum, nec ullamcorper diam iaculis. Mauris at est sit amet purus venenatis pretium vitae sed magna.";
memset(bitdata, sizeof(bitdata), 0);
side = qr_encode(QR_LEVEL_L, 0, lipsum, 0, bitdata);
ck_assert_int_eq(side, 73);
ck_assert_int_eq(memcmp(bitdata, RESULT_ALPHA_5, bitsize(side)), 0);
memset(bitdata, sizeof(bitdata), 0);
side = qr_encode(QR_LEVEL_M, 0, lipsum, 0, bitdata);
ck_assert_int_eq(side, 85);
ck_assert_int_eq(memcmp(bitdata, RESULT_ALPHA_6, bitsize(side)), 0);
memset(bitdata, sizeof(bitdata), 0);
side = qr_encode(QR_LEVEL_Q, 0, lipsum, 0, bitdata);
ck_assert_int_eq(side, 97);
ck_assert_int_eq(memcmp(bitdata, RESULT_ALPHA_7, bitsize(side)), 0);
memset(bitdata, sizeof(bitdata), 0);
side = qr_encode(QR_LEVEL_H, 0, lipsum, 0, bitdata);
ck_assert_int_eq(side, 109);
ck_assert_int_eq(memcmp(bitdata, RESULT_ALPHA_8, bitsize(side)), 0);
#endif
}
// Assume _size is already a power of 2
// map must point to a memory area written by "write_blocks". No header
array(char *map, size_t _size, uint_t _key_len, uint_t _val_len,
uint_t _reprobe_limit, size_t *_reprobes,
SquareBinaryMatrix &_hash_matrix,
SquareBinaryMatrix &_hash_inverse_matrix) :
lsize(ceilLog2(_size)), size(_size), size_mask(size-1),
reprobe_limit(_reprobe_limit, _reprobes, size), key_len(_key_len),
key_mask(key_len <= lsize ? 0 : (((word)1) << (key_len - lsize)) - 1),
key_off(key_len <= lsize ? 0 : key_len - lsize),
offsets(key_off + bitsize(reprobe_limit.val() + 1), _val_len,
reprobe_limit.val() + 1),
data((word *)map), reprobes(_reprobes),
hash_matrix(_hash_matrix), hash_inverse_matrix(_hash_inverse_matrix)
{ }
void set(uint64_t i, uint64_t x, vector< uint64_t >& new_words, uint8_t& new_int_per_word_, uint8_t& new_width_, uint64_t& new_MASK ){
assert(bitsize(x)<=new_width_);
uint64_t word_nr = i/new_int_per_word_;
uint8_t pos = i%new_int_per_word_;
//set to 0 i-th entry
uint64_t MASK1 = ~(new_MASK<<(new_width_*pos));
new_words[word_nr] &= MASK1;
//insert x inside i-th position
new_words[word_nr] |= (x<<(new_width_*pos));
}
void set(uint64_t i, uint64_t x){
assert(bitsize(x)<=width_);
uint64_t word_nr = i/int_per_word_;
uint8_t pos = i%int_per_word_;
//set to 0 i-th entry
uint64_t MASK1 = ~(MASK<<(width_*pos));
words[word_nr] &= MASK1;
//insert x inside i-th position
words[word_nr] |= (x<<(width_*pos));
}
array(size_t _size, uint_t _key_len, uint_t _val_len,
uint_t _reprobe_limit, size_t *_reprobes) :
lsize(ceilLog2(_size)), size(((size_t)1) << lsize),
size_mask(size - 1),
reprobe_limit(_reprobe_limit, _reprobes, size), key_len(_key_len),
key_mask(key_len <= lsize ? 0 : (((word)1) << (key_len - lsize)) - 1),
key_off(key_len <= lsize ? 0 : key_len - lsize),
offsets(key_off + bitsize(reprobe_limit.val() + 1), _val_len,
reprobe_limit.val() + 1),
mem_block(div_ceil(size, (size_t)offsets.get_block_len()) * offsets.get_block_word_len() * sizeof(word)),
data((word *)mem_block.get_ptr()), reprobes(_reprobes),
hash_matrix(key_len),
hash_inverse_matrix(hash_matrix.init_random_inverse())
{
if(!data)
eraise(ErrorAllocation) << "Failed to allocate "
<< (div_ceil(size, (size_t)offsets.get_block_len()) * offsets.get_block_word_len() * sizeof(word))
<< " bytes of memory";
}
hacked_vector to_vector(uint64_t j,uint64_t y){
auto w2 = std::max(width_,bitsize(y));
auto vec = hacked_vector(size_+1,w2);
//vector<uint64_t> vec(size_+1);
uint64_t i = 0;
for(uint64_t k=0;k<size_;++k){
if(k==j) vec[i++] = y;
vec[i++] = at(k);
}
if(j==size_) vec[size_] = y;
return vec;
}
Values keygen(unsigned int bits){
RNG::BBS(static_cast <MPI> (static_cast <unsigned int> (now()))); // seed just in case not seeded
bits /= 5;
// random prime q - only used for key generation
MPI q = bintompi(RNG::BBS().rand(bits));
q = nextprime(q);
while (bitsize(q) > bits){
q = bintompi(RNG::BBS().rand(bits));
q = nextprime(q);
}
bits *= 5;
// random prime p = kq + 1
MPI p = bintompi("1" + RNG::BBS().rand(bits - 1)); // pick random starting point
p = ((p - 1) / q) * q + 1; // set starting point to value such that p = kq + 1 for some k, while maintaining bitsize
while (!knuth_prime_test(p, 25)){
p += q;
}
// generator g with order p
MPI g = 1;
MPI h = 1;
MPI exp = (p - 1) / q;
while (g == 1){
g = powm(++h, exp, p);
}
// 0 < x < p
MPI x = 0;
while ((x == 0) || (p <= x)){
x = bintompi(RNG::BBS().rand(bits));
}
// y = g^x mod p
MPI y;
y = powm(g, x, p);
return {p, g, y, x};
}
/*
* efficient push-back, implemented with a push-back on the underlying container
* the insertion of an element whose bit-size exceeds the current width causes a
* rebuild of the whole vector!
*/
void push_back(uint64_t x){
if(bitsize(x)>width_){
//auto vec = to_vector(size(),x);
//rebuild(vec);
rebuild_ins(size(), x);
return;
}
//not enough space for the new element:
//push back a new word
if(size_+1>(words.size()*(int_per_word_))) words.push_back(0);
//insert x
set(size(),x);
size_++;
}
//-----------------------------------------------------------------------------
// 將值寫入旗標
bool C_FlagCtrl::SetValue(IN unsigned long ulPos, IN unsigned long ulSize, IN int iValue)
{
if(m_pData == nullptr)
return false;
if(ulPos >= m_ulSize)
return false;
if(ulPos + ulSize >= m_ulSize)
return false;
if(bitsize(iValue) > ulSize)
return false;
for(int i = ulSize - 1; i >= 0; i--, iValue /= 2)
{
if(iValue % 2)
Set(i + ulPos);
else
Reset(i + ulPos);
}//for
return true;
}
pHit
Any::match_in_local(const char* buf, size_t len,
bir roi) const
{
return (bitsize() <= roi.bitsize()) ? pHit(roi.low(), bitsize()) : pHit();
}
