void search(struct list * a)
{
int x;
printf("1、按姓名查找\n");
printf("2、按地址查找\n");
printf("3、按电话查找\n");
scanf("%d",&x);
if(x==1)
search_n(a);
if(x==2)
search_a(a);
if(x==3)
search_t(a);
system("pause");
}
void MainWindow::on_search_clicked()
{
sd=ui->lineEdit->text();
search_t(sd);
}
int tfel_decrypt_cp(char *inputfile, char *keyfile, char *output) {
int i;
FILE *fp;
//pubkey input //共通
tfel_pubkey *pubkey = NULL;
pubkey = (tfel_pubkey*)malloc(sizeof(tfel_pubkey));
if (pubkey == NULL) return -1;
tfel_param_G *param_G;
param_G = (tfel_param_G*)malloc(sizeof(tfel_param_G));
if (param_G == NULL) {
tfel_clear_pk(pubkey->num_att, pubkey);
free(pubkey);
return -1;
}
memset(param_G, 0, sizeof(tfel_param_G));
pairing_init(param_G->p, CURVE);
importpub(pubkey, *param_G);
//pubkey input
//sk_Gamma input //CP
secretkey sk_Gamma;
sk_Gamma.sk_Delta = (attribute_set*)malloc(sizeof(attribute_set));
sk_Gamma.sk_AS = NULL;
sk_Gamma.sk_kStar = (basis*)malloc(sizeof(basis));
import_sk(sk_Gamma.sk_Delta, sk_Gamma.sk_kStar, *param_G, keyfile);
//sk_Gamma input
//ciphertext input //共通
char *input_buf = NULL;//,*keyfile_buf = NULL;
char *aes_blob64 = NULL, *abe_blob64 = NULL, *iv_blob64 = NULL;
ssize_t input_len;
size_t key_len;
fp = fopen(inputfile, "r");
if(fp != NULL) {
if((input_len = read_file(fp, &input_buf)) > 0) {
tokenize_inputfile(input_buf, &abe_blob64, &aes_blob64, &iv_blob64);
if(aes_blob64 == NULL || abe_blob64 == NULL || iv_blob64 == NULL) {
fprintf(stderr, "Input file either not well-formed or not encrypted.\n");
fclose(fp);
return -1;
}
free(input_buf);
}
}
else {
fprintf(stderr, "Could not load input file: %s\n", inputfile);
return FALSE;
}
fclose(fp);
//ciphertext input
//decode ciphertext //共通
tfel_ciphertext ct;
memset(&ct, 0, sizeof(tfel_ciphertext));
size_t abeLength;
unsigned char *data = NewBase64Decode((const char *) abe_blob64, strlen(abe_blob64), &abeLength);
ct.data = data;
ct.data_len = abeLength;
ct.max_len = abeLength;
//decode ciphertext
//deserialize ciphertext
/*printf("abe_blob64 = %zd\n", strlen(abe_blob64));
printf("abeLength = %zd\n", abeLength);
printf("ct.data = %s\n", ct.data);
printf("ct.data_len = %zd\n", ct.data_len);
printf("ct.max_len = %zd\n", ct.max_len);*/
basis *c_i = NULL;
c_i = (basis*)malloc(sizeof(basis));
if (c_i == NULL){
//error処理
}
AccessStructure *AS = NULL;
AS = (AccessStructure*)malloc(sizeof(AccessStructure));
tfel_deserialize_ciphertext_cp(AS, c_i, ct.data, ct.max_len, param_G->p);
//deserialize ciphertext
//decode iv
size_t ivLength;
char *ivec = NewBase64Decode((const char *) iv_blob64, strlen(iv_blob64), &ivLength);
//debug("IV: ");
//print_buffer_as_hex((uint8 *) ivec, AES_BLOCK_SIZE);
//decode iv
//decode aes
/* decode the aesblob64 */
size_t aesLength;
char *aesblob = NewBase64Decode((const char *) aes_blob64, strlen(aes_blob64), &aesLength);
//printf("sizeof(aesblob) = %zd\n", aesLength);
//decode aes
//拡大係数行列のチェック
printf("check\n");
AccessStructure *aAS;
aAS = check_attribute_to_matrix(sk_Gamma.sk_Delta, AS); //errorならNULLを返す
//alpha_iを生成
mpz_t order;
mpz_init(order);
mpz_set(order, *pairing_get_order(param_G->p));
mpz_t *alpha_i;
mpz_t temp;
mpz_init(temp);
Element *K;
Element *temp_E;
Element temp_0;
element_init(temp_0, param_G->p->g3);
alpha_i = calc_alpha_i(aAS, order);
rho_i *r_ptr;
r_ptr = aAS->rho;
int t; //search_tで使用
for (i = 0; i < aAS->num_policy+1; i++) { //generate K
if (i == 0) {
K = pairing_c_k(param_G->p, NULL, c_i->M[0], sk_Gamma.sk_kStar->M[0], NULL);
}
else {
t = search_t(r_ptr, sk_Gamma.sk_Delta); //r_ptrからtを持ってくる関数
temp_E = pairing_c_k(param_G->p, r_ptr, c_i->M[i], sk_Gamma.sk_kStar->M[t], &alpha_i[i-1]);
//temp_E = pairing_c_k(param_G->p, r_ptr, c_i->M[t], sk_Gamma.sk_kStar->M[i], &alpha_i[i-1]);
element_mul(temp_0, *temp_E, *K);
element_set(*K, temp_0);
element_clear(*temp_E);
free(temp_E);
r_ptr = r_ptr->next;
}
}
//printf("K generate\n");
//Kのバイト列を16ビットのハッシュに
key_len = element_get_oct_length(*K); // size of K
unsigned char *K_oct;
K_oct = (unsigned char*)malloc(sizeof(unsigned char)*key_len);
element_to_oct(K_oct, &key_len, *K); // bytes of K
unsigned char *session_key;
session_key = (unsigned char *)malloc(sizeof(unsigned char)*16);
//int d_len;
hash_to_bytes(K_oct, key_len, SESSION_KEY_LEN, session_key, 2);
//Kのバイト列を16ビットのハッシュに
//復号
AES_KEY sk;
//char aes_result[aesLength+1];
char *aes_result;
aes_result = (char*)malloc(sizeof(char)*aesLength+1);
AES_set_decrypt_key((uint8 *) session_key, 8*SESSION_KEY_LEN, &sk);
memset(aes_result, 0, aesLength+1);
AES_cbc_encrypt((uint8 *) aesblob, (uint8 *) aes_result, aesLength, &sk, (uint8 *) ivec, AES_DECRYPT);
char magic[strlen(MAGIC)+1];
memset(magic, 0, strlen(MAGIC)+1);
strncpy(magic, aes_result, strlen(MAGIC));
if(strcmp(magic, MAGIC) == 0) {
//printf("Recovered magic: '%s'\n", magic);
//printf("Plaintext: %s\n", (char *) (aes_result + strlen(MAGIC)));
if ((fp = fopen(output, "w")) == NULL) {
fprintf(stderr, "output open error\n");
}
else {
fprintf(fp, "%s\n", (char*)(aes_result + strlen(MAGIC)));
fclose(fp);
}
//magic_failed = FALSE;
}
else {
printf("error decryption\n");
//printf(stderr, "ERROR: ABE decryption unsuccessful!!\n");
//magic_failed = TRUE;
}
//復号
free(aesblob);
free(aes_blob64);
free(ivec);
free(iv_blob64);
free(data);
free(abe_blob64);
free(aes_result);
//free(&input_buf);
free(session_key);
free(K_oct);
element_clear(*K);
free(K);
if (aAS != NULL) {
for (i = 0; i < aAS->S->row; i++) {
mpz_clear(alpha_i[i]);
}
free(alpha_i);
AccessStructure_clear(aAS);//error
}
element_clear(temp_0);
mpz_clear(order);
mpz_clear(temp);
for (i = 0; i < c_i->dim; i++) { //memsetとか追加？
free(c_i->M[i]);
}
free(c_i->M);
free(c_i);
Spanprogram_clear(AS->S);
free(AS);
//AccessStructure_clear(AS);//すでにAS->rhoがAccessStructure_clear(aAS)により解放されているため
return 0;
}
std::vector<Search::TetrisNodeWithTSpinType> const *Search::search(TetrisMap const &map, TetrisNode const *node)
{
land_point_cache_.clear();
if(!node->check(map))
{
return &land_point_cache_;
}
bool allow_180 = config_->allow_180;
node_mark_.clear();
node_mark_filtered_.clear();
node_search_.clear();
if(node->status.t == 'T')
{
return search_t(map, node);
}
if(node->land_point != nullptr && node->low >= map.roof)
{
for(auto cit = node->land_point->begin(); cit != node->land_point->end(); ++cit)
{
TetrisNode const *drop_node = (*cit)->drop(map);
if(node_mark_filtered_.mark(drop_node))
{
land_point_cache_.push_back(drop_node);
}
node_search_.push_back(drop_node);
}
TetrisNode const *last_node = nullptr;
size_t cache_index = node_search_.size();
for(size_t i = 0; i != cache_index; ++i)
{
node = node_search_[i];
if(last_node != nullptr)
{
if(last_node->status.r == node->status.r && std::abs(last_node->status.x - node->status.x) == 1 && std::abs(last_node->status.y - node->status.y) > 1)
{
if(last_node->status.y > node->status.y)
{
TetrisNode const *check_node = (last_node->*(last_node->status.x > node->status.x ? &TetrisNode::move_left : &TetrisNode::move_right))->move_down->move_down;
if(node_mark_.mark(check_node))
{
node_search_.push_back(check_node);
}
}
else
{
TetrisNode const *check_node = (node->*(node->status.x > last_node->status.x ? &TetrisNode::move_left : &TetrisNode::move_right))->move_down->move_down;
if(node_mark_.mark(check_node))
{
node_search_.push_back(check_node);
}
}
}
}
last_node = node;
}
do
{
for(size_t max_index = node_search_.size(); cache_index < max_index; ++cache_index)
{
node = node_search_[cache_index];
if(!node->open(map) && (!node->move_down || !node->move_down->check(map)))
{
if(node_mark_filtered_.mark(node))
{
land_point_cache_.push_back(node);
}
}
if(allow_180)
{
//x
for(TetrisNode const *wall_kick_node : node->wall_kick_opposite)
{
if(wall_kick_node)
{
if(wall_kick_node->check(map))
{
if(node_mark_.mark(wall_kick_node) && !wall_kick_node->open(map))
{
node_search_.push_back(wall_kick_node);
}
break;
}
}
else
{
break;
}
}
}
//z
for(TetrisNode const *wall_kick_node : node->wall_kick_counterclockwise)
{
if(wall_kick_node)
{
if(wall_kick_node->check(map))
{
if(node_mark_.mark(wall_kick_node) && !wall_kick_node->open(map))
{
node_search_.push_back(wall_kick_node);
}
break;
}
}
else
{
break;
}
}
//c
for(TetrisNode const *wall_kick_node : node->wall_kick_clockwise)
{
if(wall_kick_node)
{
if(wall_kick_node->check(map))
{
if(node_mark_.mark(wall_kick_node) && !wall_kick_node->open(map))
{
node_search_.push_back(wall_kick_node);
}
break;
}
}
else
{
break;
}
}
//l
if(node->move_left && node_mark_.mark(node->move_left) && !node->move_left->open(map) && node->move_left->check(map))
{
node_search_.push_back(node->move_left);
}
//r
if(node->move_right && node_mark_.mark(node->move_right) && !node->move_right->open(map) && node->move_right->check(map))
{
node_search_.push_back(node->move_right);
}
//d
if(node->move_down && node_mark_.mark(node->move_down) && node->move_down->check(map))
{
node_search_.push_back(node->move_down);
}
}
}
while(node_search_.size() > cache_index);
}
else
{
node_search_.push_back(node);
node_mark_.mark(node);
size_t cache_index = 0;
do
{
for(size_t max_index = node_search_.size(); cache_index < max_index; ++cache_index)
{
node = node_search_[cache_index];
if(!node->move_down || !node->move_down->check(map))
{
if(node_mark_filtered_.mark(node))
{
land_point_cache_.push_back(node);
}
}
if(allow_180)
{
//x
for(TetrisNode const *wall_kick_node : node->wall_kick_opposite)
{
if(wall_kick_node)
{
if(wall_kick_node->check(map))
{
if(node_mark_.mark(wall_kick_node))
{
node_search_.push_back(wall_kick_node);
}
break;
}
}
else
{
break;
}
}
}
//z
for(TetrisNode const *wall_kick_node : node->wall_kick_counterclockwise)
{
if(wall_kick_node)
{
if(wall_kick_node->check(map))
{
if(node_mark_.mark(wall_kick_node))
{
node_search_.push_back(wall_kick_node);
}
break;
}
}
else
{
break;
}
}
//c
for(TetrisNode const *wall_kick_node : node->wall_kick_clockwise)
{
if(wall_kick_node)
{
if(wall_kick_node->check(map))
{
if(node_mark_.mark(wall_kick_node))
{
node_search_.push_back(wall_kick_node);
}
break;
}
}
else
{
break;
}
}
//l
if(node->move_left && node_mark_.mark(node->move_left) && node->move_left->check(map))
{
node_search_.push_back(node->move_left);
}
//r
if(node->move_right && node_mark_.mark(node->move_right) && node->move_right->check(map))
{
node_search_.push_back(node->move_right);
}
//d
if(node->move_down && node_mark_.mark(node->move_down) && node->move_down->check(map))
{
node_search_.push_back(node->move_down);
}
}
}
while(node_search_.size() > cache_index);
}
return &land_point_cache_;
}
