Homec4science
Diffusion SecGene-i2b2 (master) Browse

SecGene/importation-tool/ImportationTool.cpp
b1b9039b9ac2master

Last Change
Raw File

ImportationTool.cpp
View Options

#include <fstream>
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <iomanip>
#include <pqxx/pqxx>
#include "edu_harvard_i2b2_gen_util_CryptosystemBridge.cpp"
#define MAX_ENTRY 10000
using namespace std;
using namespace pqxx;
connection* connectDB(string);
void disconnectDB(connection*);
result* NON_TRANSACTIONstatement(connection*, string);
void TRANSACTIONstatement(connection*, string);
void skipLine(ifstream*);
void readBlock(char*, ifstream*);
void skipBlock(ifstream*, unsigned short);
void writeKeySet(FV::sk_t*, FV::evk_t*, FV::pk_t*);
void loadKeySet(ifstream*, FV::sk_t*, FV::evk_t*, FV::pk_t*);
void writeLittleEndian(ofstream*, uint64_t);
bool isLast(ifstream*);
void printUsage(char*);
void generateRandomAlphaNumeric(char*, int);
void moreSpaceEncoding(uint64_t, int, unsigned int, unsigned int, ifstream*, streampos*, ofstream*, unsigned int, char*, FV::pk_t*);
void lessSpaceEncoding(uint64_t, int, unsigned int, unsigned int, ifstream*, streampos*, ofstream*, unsigned int, char*, FV::pk_t*);
void encrypt(FV::pk_t*, FV::params::poly_p*, ofstream*);
int main(int argc, char* argv[]) {
if (argc < 2) {
printUsage(argv[0]);
return 1;
}
if (strcmp(argv[1], "-u") == 0) {
if (argc != 5) {
printUsage(argv[0]);
return 1;
}
ifstream ifs;
ofstream ofs;
srand (time(NULL));
ifs.open(argv[2]);
FV::params::poly_p sk;
FV::params::poly_p pk;
for (size_t i=0;i<POLY_DEGREE;i++) {
uint64_t v;
ifs.read((char*)&v, sizeof(uint64_t));
uint64_t r = rand();
r = (r << 32) | rand();
r %= v;
pk(0,i) = r;
sk(0,i) = v-r;
}
ifs.close();
//pk.invntt_pow_invphi();
char* id = (char*) malloc(51*sizeof(char));
generateRandomAlphaNumeric(id, 50);
ofs.open("proxy.sql");
ofs << "insert into gen_proxy_partial_key_mapping (partial_key_id, partial_key) values" << endl;
ofs << "(\'" << id << "\', E'\\\\x";
for (size_t i=0;i<POLY_DEGREE;i++) {
writeLittleEndian(&ofs, pk(0,i));
}
ofs << "');" << endl;;
ofs.close();
ofs.open("i2b2server.sql");
ofs << "insert into gen_partial_key_set (partial_key_id, partial_key) values" << endl;
ofs << "(\'" << id << "\', E'\\\\x";
for (size_t i=0;i<POLY_DEGREE;i++) {
writeLittleEndian(&ofs, sk(0,i));
}
ofs << "');" << endl;;
ofs << "insert into gen_user_mapping (user_id, access_level, partial_key_id) values" << endl;
ofs << "(\'" << argv[3] << "\', " << argv[4] << ", \'" << id << "\');" << endl;
ofs.close();
free(id);
cout << "DONE" << endl;
cout << "Please execute proxy.sql, i2b2server.sql on each server" << endl;
return 0;
} else if (strcmp(argv[1], "-f") == 0) {
connection* C = connectDB("dbname=i2b2importationtool user=i2b2importationtool password=i2b2importationtool \
hostaddr=127.0.0.1 port=5432");
bool clear_database=false;
bool new_encoding=false;
if(argc >=2 && strcmp(argv[2], "-d") == 0){
clear_database=true;
NON_TRANSACTIONstatement(C,"SELECT setval(\'public.patient_seq\',1)");
TRANSACTIONstatement(C,"DELETE FROM public.gen_variants;");
}else{
result* rs = NON_TRANSACTIONstatement(C,"SELECT nextval(\'public.patient_seq\')");
uint64_t aux = rs->front()[0].as<uint64_t>();
delete rs;
NON_TRANSACTIONstatement(C,"SELECT setval(\'public.patient_seq\',"+to_string(aux-1)+")");
}
if( (argc >2 && strcmp(argv[2], "-i") == 0) || (argc >3 && strcmp(argv[3], "-i") == 0) ){
new_encoding=true;
}
ifstream ifs, keyset;
ofstream ofs, res, aggregate;
FV::sk_t* secret_key = new FV::sk_t();
FV::evk_t* evaluation_key = new FV::evk_t(*secret_key, 32);
FV::pk_t* public_key = new FV::pk_t(*secret_key, *evaluation_key);
// Write key set
if ((argc == 3 && clear_database == false && new_encoding == false) || (argc == 4 && clear_database == true && new_encoding == false) ||
(argc == 4 && clear_database == false && new_encoding == true) || (argc == 5 && clear_database == true && new_encoding == true)) {
cout << "Generate new keyset" << endl;
writeKeySet(secret_key, evaluation_key, public_key);
ifs.open(argv[argc-1]);
} else if ((argc == 4 && clear_database == false && new_encoding == false) || (argc == 5 && clear_database == true && new_encoding == false) ||
(argc == 5 && clear_database == false && new_encoding == true) || (argc == 6 && clear_database == true && new_encoding == true)) {
// Load exist key
cout << "Load existing keyset" << endl;
keyset.open(argv[argc-1]);
loadKeySet(&keyset, secret_key, evaluation_key, public_key);
keyset.close();
ifs.open(argv[argc-2]);
} else {
printUsage(argv[0]);
return 1;
}
// skip header
char c;
do {
skipLine(&ifs);
ifs.seekg(1, ifs.cur);
ifs.get(c);
} while (c == '#');
// Get individuals number
// skip column definition, 9 columns #CHROM, POS, ID, REF, ALT, QUAL, FILTER, INFO, FORMAT are metadata
// need to parse patient identifier
int count=-9;
do {
skipBlock(&ifs, 1);
count++;
ifs.get(c);
} while (c != '\n');
if (count <= 0) {
cout << "No one is in given files" << endl;
return 1;
}
cout << count << " individual(s) are found" << endl;
result* rs = NON_TRANSACTIONstatement(C,"SELECT currval(\'public.patient_seq\')");
uint64_t patients_log = rs->front()[0].as<uint64_t>();
delete rs;
ofs.open("individuals.sql");
ofs << "insert into gen_patient_mapping(pid_gen) values" << endl;
for (int i=0;i<count;i++) {
ofs << "(" << (patients_log+i) << ")," << endl;
NON_TRANSACTIONstatement(C,"SELECT nextval(\'public.patient_seq\')");
}
ofs.seekp(-2, ofs.end);
ofs << ';';
ofs.close();
streampos* pos = (streampos*) malloc(POLY_DEGREE*sizeof(streampos));
vector<char*> container;
for(int param=0; param<5; param++){
char* buffer = (char*) malloc(1024*sizeof(char));
container.push_back(buffer);
}
char* buffer = (char*) malloc(1024*sizeof(char));
unsigned int cipherid;
unsigned int degree;
if(clear_database==true){
cipherid=0;
degree=0;
}else{
result* rs = NON_TRANSACTIONstatement(C,"SELECT cipher_id, degree FROM public.gen_variants ORDER BY cipher_id, degree DESC LIMIT 1;");
if(rs->size()>0){
cipherid = rs->front()[0].as<unsigned int>();
degree = rs->front()[1].as<unsigned int>();
if(degree<POLY_DEGREE - 1){
degree++;
}else{
cipherid++;
degree=0;
}
}else{
cipherid=0;
degree=0;
}
}
unsigned int n = POLY_DEGREE;
bool hasNext = true;
long variants = 0;
int fileId = 0;
int NbEntries = 0;
bool new_variants = false;
ofs.open("variants.sql");
ofs << "delete from gen_noisy_result;" << endl;
ofs << "insert into gen_variants (cipher_id, degree, chromosome, position, rs_number, reference, alternate) values" << endl;
aggregate.open("genotypes.sql");
aggregate << "\\i genotypes-0.sql" << endl;
res.open("genotypes-0.sql");
if(new_encoding == false){
res << "insert into gen_encrypted_genotypes (cipher_id, pid_gen, cipher_gt1, cipher_gt2, no_calls) values" << endl;
}else{
res << "insert into gen_encrypted_genotypes (cipher_id, pid_gen, cipher_gt1, cipher_gt2, cipher_gt3, cipher_gt4, cipher_gt5) values" << endl;
}
while (hasNext) {
if (NbEntries >= MAX_ENTRY) {
res.seekp(-2, res.end);
res << ';';
res.close();
fileId++;
NbEntries = 0;
aggregate << "\\i genotypes-" << to_string(fileId) << ".sql" << endl;
res.open("genotypes-" + to_string(fileId) + ".sql");
if(new_encoding == false){
res << "insert into gen_encrypted_genotypes (cipher_id, pid_gen, cipher_gt1, cipher_gt2, no_calls) values" << endl;
}else{
res << "insert into gen_encrypted_genotypes (cipher_id, pid_gen, cipher_gt1, cipher_gt2, cipher_gt3, cipher_gt4, cipher_gt5) values" << endl;
}
}
// parse variant information
for (size_t i=degree;i<n;i++) {
// read variant information
readBlock(container[0], &ifs); // chromosome
readBlock(container[1], &ifs); // position
readBlock(container[2], &ifs); // rs_number
readBlock(container[3], &ifs); // reference
readBlock(container[4], &ifs); // alternate
string select_query="",insert_query="";
if (*container[2] == '.') {
select_query="SELECT COUNT(*) FROM public.gen_variants WHERE chromosome=\'"+string(container[0])+"\' AND \"position\"="+string(container[1])+" AND rs_number=\'"+string(container[2])+"\' and reference=\'"+string(container[3])+"\' AND alternate=\'"+string(container[4])+"\';";
insert_query="INSERT INTO public.gen_variants (cipher_id, degree, chromosome, position, rs_number, reference, alternate) VALUES ("+to_string(cipherid)+","+to_string(i)+",\'"+string(container[0])+"\',"+string(container[1])+",\'"+string(container[2])+"\',\'"+string(container[3])+"\',\'"+string(container[4])+"\');";
}else{
select_query="SELECT COUNT(*) FROM public.gen_variants WHERE chromosome=\'"+string(container[0])+"\' AND \"position\"="+string(container[1])+" AND rs_number=\'"+string(container[2])+"\' AND reference=\'"+string(container[3])+"\' AND alternate=\'"+string(container[4])+"\';";
insert_query="INSERT INTO public.gen_variants (cipher_id, degree, chromosome, position, rs_number, reference, alternate) VALUES ("+to_string(cipherid)+","+to_string(i)+",\'"+string(container[0])+"\',"+string(container[1])+",\'"+string(container[2])+"\',\'"+string(container[3])+"\',\'"+string(container[4])+"\');";
}
// check if variant exists
result* rs = NON_TRANSACTIONstatement(C,select_query);
bool exists = rs->front()[0].as<bool>();
delete rs;
if(exists == false){
new_variants = true;
TRANSACTIONstatement(C,insert_query);
// if variant does not yet exist write to file
ofs << '(' << cipherid << ", " << i << ", \'"; // cipher_id
ofs << container[0] << "\', "; // chromosome
ofs << container[1] << ", "; // position
// rs_number
if (*container[2] == '.') {
ofs << "null";
} else {
ofs << '\'' << container[2] << '\'';
}
ofs << ", \'";
ofs << container[3] << "\', \'"; // reference
ofs << container[4] << "\'),"; // alternate
ofs << endl;
}
skipBlock(&ifs, 4);
*(pos+i-degree) = ifs.tellg();
skipLine(&ifs);
if (isLast(&ifs)) {
n=i+1-degree;
hasNext = false;
ifs.clear();
}
degree = 0;
}
if(new_encoding==false){
lessSpaceEncoding(patients_log,count,degree,n,&ifs,pos,&res,cipherid,buffer,public_key);
NbEntries += 2*count;
}else{
moreSpaceEncoding(patients_log,count,degree,n,&ifs,pos,&res,cipherid,buffer,public_key);
NbEntries += 5*count;
}
skipLine(&ifs);
cipherid++;
variants += n;
cout << variants << " variants are processed" << endl;
}
// replace , of last column to ;
ofs.seekp(-2, ofs.end);
ofs << ';';
res.seekp(-2, res.end);
res << ';';
ifs.close();
ofs.close();
if(new_variants == false){
ofs.open("variants.sql");
ofs.close();
}
res.close();
aggregate.close();
for(size_t i=0;i<container.size();i++){
free(container[i]);
}
free(buffer);
free(pos);
delete secret_key;
delete evaluation_key;
delete public_key;
disconnectDB(C);
cout << "DONE" << endl;
cout << "Please execute individuals.sql, variants.sql, genotypes.sql";
if (argc == 3)
cout << ", parameters.sql";
cout << " to load data" << endl;
return 0;
} else {
printUsage(argv[0]);
return 1;
}
}
void moreSpaceEncoding(uint64_t patients_log, int count, unsigned int degree, unsigned int n, ifstream* ifs, streampos* pos, ofstream* res, unsigned int cipherid, char* buffer, FV::pk_t* public_key){
for (uint64_t i=patients_log; i<patients_log+count; i++) {
// for each individual
FV::params::poly_p gt1;
FV::params::poly_p gt2;
FV::params::poly_p gt3;
FV::params::poly_p gt4;
FV::params::poly_p gt5;
for (size_t j=0;j<degree;j++) {
gt1(0,j) = (uint64_t)0;
gt2(0,j) = (uint64_t)0;
gt3(0,j) = (uint64_t)0;
gt4(0,j) = (uint64_t)0;
gt5(0,j) = (uint64_t)0;
}
for (size_t j=degree;j<n;j++) {
ifs->seekg(*(pos+j-degree));
readBlock(buffer,ifs);
*(pos+j-degree) = ifs->tellg();
if (*buffer == '0') {
if (*(buffer+2) == '0') {
gt1(0,j) = (uint64_t)1;
gt2(0,j) = (uint64_t)0;
gt3(0,j) = (uint64_t)0;
gt4(0,j) = (uint64_t)0;
gt5(0,j) = (uint64_t)2;
} else if (*(buffer+2) == '.') {
gt1(0,j) = (uint64_t)0;
gt2(0,j) = (uint64_t)0;
gt3(0,j) = (uint64_t)0;
gt4(0,j) = (uint64_t)0;
gt5(0,j) = (uint64_t)1;
} else {
gt1(0,j) = (uint64_t)0;
gt2(0,j) = (uint64_t)1;
gt3(0,j) = (uint64_t)0;
gt4(0,j) = (uint64_t)1;
gt5(0,j) = (uint64_t)2;
}
} else if (*buffer == '.') {
if (*(buffer+2) == '0') {
gt1(0,j) = (uint64_t)0;
gt2(0,j) = (uint64_t)0;
gt3(0,j) = (uint64_t)0;
gt4(0,j) = (uint64_t)0;
gt5(0,j) = (uint64_t)1;
} else if (*(buffer+2) == '.') {
gt1(0,j) = (uint64_t)0;
gt2(0,j) = (uint64_t)0;
gt3(0,j) = (uint64_t)0;
gt4(0,j) = (uint64_t)0;
gt5(0,j) = (uint64_t)0;
} else {
gt1(0,j) = (uint64_t)0;
gt2(0,j) = (uint64_t)0;
gt3(0,j) = (uint64_t)0;
gt4(0,j) = (uint64_t)1;
gt5(0,j) = (uint64_t)1;
}
} else {
if (*(buffer+2) == '0') {
gt1(0,j) = (uint64_t)0;
gt2(0,j) = (uint64_t)1;
gt3(0,j) = (uint64_t)0;
gt4(0,j) = (uint64_t)1;
gt5(0,j) = (uint64_t)2;
} else if (*(buffer+2) == '.') {
gt1(0,j) = (uint64_t)0;
gt2(0,j) = (uint64_t)0;
gt3(0,j) = (uint64_t)0;
gt4(0,j) = (uint64_t)1;
gt5(0,j) = (uint64_t)1;
} else {
gt1(0,j) = (uint64_t)0;
gt2(0,j) = (uint64_t)0;
gt3(0,j) = (uint64_t)1;
gt4(0,j) = (uint64_t)2;
gt5(0,j) = (uint64_t)2;
}
}
}
*res << '(' << dec << cipherid << ',' << i;
encrypt(public_key,&gt1,res);
encrypt(public_key,&gt2,res);
encrypt(public_key,&gt3,res);
encrypt(public_key,&gt4,res);
encrypt(public_key,&gt5,res);
*res << ")," << endl;
}
}
void lessSpaceEncoding(uint64_t patients_log, int count, unsigned int degree, unsigned int n, ifstream* ifs, streampos* pos, ofstream* res, unsigned int cipherid, char* buffer, FV::pk_t* public_key){
for (uint64_t i=patients_log; i<patients_log+count; i++) {
// for each individual
FV::params::poly_p gt1;
FV::params::poly_p gt2;
unsigned char* noc = (unsigned char*) malloc(POLY_DEGREE/4*sizeof(char));
for (size_t j=0;j<degree;j++) {
if (j%4 == 0) {
*(noc+j/4)=0;
}
*(noc+j/4) |= 0x02 << 2*(j%4);
}
for (size_t j=degree;j<n;j++) {
ifs->seekg(*(pos+j-degree));
readBlock(buffer,ifs);
*(pos+j-degree) = ifs->tellg();
if (j%4 == 0) {
*(noc+j/4)=0;
}
if (*buffer == '0') {
if (*(buffer+2) == '0') {
gt1(0,j) = (uint64_t)0;
gt2(0,j) = (uint64_t)0;
} else if (*(buffer+2) == '.') {
gt1(0,j) = (uint64_t)0;
gt2(0,j) = (uint64_t)1;
*(noc+j/4) |= 0x01 << 2*(j%4);
} else {
gt1(0,j) = (uint64_t)1;
gt2(0,j) = (uint64_t)0;
}
} else if (*buffer == '.') {
if (*(buffer+2) == '0') {
gt1(0,j) = (uint64_t)0;
gt2(0,j) = (uint64_t)1;
*(noc+j/4) |= 0x01 << 2*(j%4);
} else if (*(buffer+2) == '.') {
gt1(0,j) = (uint64_t)0;
gt2(0,j) = (uint64_t)0;
*(noc+j/4) |= 0x02 << 2*(j%4);
} else {
gt1(0,j) = (uint64_t)1;
gt2(0,j) = (uint64_t)0;
*(noc+j/4) |= 0x01 << 2*(j%4);
}
} else {
if (*(buffer+2) == '0') {
gt1(0,j) = (uint64_t)1;
gt2(0,j) = (uint64_t)0;
} else if (*(buffer+2) == '.') {
gt1(0,j) = (uint64_t)1;
gt2(0,j) = (uint64_t)0;
*(noc+j/4) |= 0x01 << 2*(j%4);
} else {
gt1(0,j) = (uint64_t)0;
gt2(0,j) = (uint64_t)1;
}
}
}
for (size_t j=n;j<POLY_DEGREE;j++) {
if (j%4 == 0) {
*(noc+j/4)=0;
}
*(noc+j/4) |= 0x02 << 2*(j%4);
}
*res << '(' << dec << cipherid << ',' << i;
encrypt(public_key,&gt1,res);
encrypt(public_key,&gt2,res);
*res << ", E'\\\\x";
for (size_t k=0;k<POLY_DEGREE/4;k++)
*res << setfill('0') << setw(2) << hex << (int)*(noc+k);
*res << "')," << endl;
free(noc);
}
}
void encrypt(FV::pk_t* public_key, FV::params::poly_p* gt, ofstream* res){
*res << ", E'\\\\x";
FV::ciphertext_t* cipher = new FV::ciphertext_t();
encrypt_poly(*cipher, *public_key, *gt);
for (size_t k=0;k<POLY_DEGREE;k++) {
writeLittleEndian(res, (cipher->c0)(0,k));
}
for (size_t k=0;k<POLY_DEGREE;k++) {
writeLittleEndian(res, (cipher->c1)(0,k));
}
*res << "'";
delete cipher;
}
connection* connectDB(string dbname){
try{
connection* C = new connection(dbname);
if (C->is_open()) {
cout << "Opened database successfully: " << C->dbname() << endl;
} else {
cout << "Can't open database" << endl;
exit(1);
}
return C;
}catch (const std::exception &e){
cerr << e.what() << std::endl;
exit(1);
}
}
void disconnectDB(connection* C){
try{
C->disconnect ();
cout << "Closed database successfully." << endl;
}catch (const std::exception &e){
cerr << e.what() << std::endl;
exit(1);
}
}
result* NON_TRANSACTIONstatement(connection* C, string statement){
try{
/* Create SQL statement */
string sql = statement;
/* Create a non-transactional object. */
nontransaction N(*C);
/* Execute SQL query */
result* R = new result(N.exec(sql));
return R;
}catch (const std::exception &e){
cerr << e.what() << std::endl;
exit(1);
}
}
void TRANSACTIONstatement(connection* C, string statement){
try{
/* Create SQL statement */
string sql = statement;
/* Create a transactional object. */
work W(*C);
/* Execute SQL query */
W.exec(sql);
W.commit();
}catch (const std::exception &e){
cerr << e.what() << std::endl;
exit(1);
}
}
void skipLine(ifstream* ifs) {
char c;
do {
ifs->get(c);
} while (c != '\n');
}
void readBlock(char* block, ifstream* ifs) {
char c;
do {
ifs->get(c);
} while (c == ' ' || c == '\t');
do {
*block = toupper(c);
ifs->get(c);
block++;
} while (c != ' ' && c != '\t' && c != '\n');
ifs->seekg(-1, ifs->cur);
*block = '\0';
}
void skipBlock(ifstream* ifs, unsigned short n) {
char c;
for (size_t i=0;i<n;i++){
do {
ifs->get(c);
} while (c == ' ' || c == '\t');
do {
ifs->get(c);
} while (c != ' ' && c != '\t' && c != '\n');
}
ifs->seekg(-1, ifs->cur);
}
void writeKeySet(FV::sk_t* sk, FV::evk_t* evk, FV::pk_t* pk) {
ofstream ofs;
ofs.open("keyset");
// write secret key
for (size_t i=0;i<POLY_DEGREE;i++) {
ofs.write((char*)&(sk->value)(0,i), sizeof(uint64_t));
}
// write public key
for (size_t i=0;i<POLY_DEGREE;i++) {
ofs.write((char*)&(pk->a)(0,i), sizeof(uint64_t));
}
for (size_t i=0;i<POLY_DEGREE;i++) {
ofs.write((char*)&(pk->b)(0,i), sizeof(uint64_t));
}
// write evaluation key
for (size_t i=0; i<evk->ell; i++) {
for (size_t j=0; j<POLY_DEGREE; j++) {
ofs.write((char*)&(*(*evk->values+i))(0,j), sizeof(uint64_t));
}
}
ofs.close();
ofs.open("parameters.sql");
ofs << "insert into gen_parameters (poly_degree, nb_moduli, public_key, evaluation_key, plaintext_modulus) values" << endl;
ofs << '(' << std::dec << POLY_DEGREE << ", " << FV::params::poly_p::nmoduli << ", E'\\\\x";
for (size_t i=0;i<POLY_DEGREE;i++) {
writeLittleEndian(&ofs, (pk->a)(0,i));
}
for (size_t i=0;i<POLY_DEGREE;i++) {
writeLittleEndian(&ofs, (pk->b)(0,i));
}
ofs << "', E'\\\\x";
for (size_t i=0; i<evk->ell; i++) {
for (size_t j=0; j<POLY_DEGREE; j++) {
writeLittleEndian(&ofs, (*(*evk->values+i))(0,j));
}
}
ofs << "', " << std::dec << FV::params::plaintextModulus<mpz_class>::value() << ");" << endl;
ofs.close();
}
void loadKeySet(ifstream* ifs, FV::sk_t* sk, FV::evk_t* evk, FV::pk_t* pk) {
for (size_t i=0;i<POLY_DEGREE;i++) {
ifs->read((char*)&(sk->value)(0,i), sizeof(uint64_t));
}
for (size_t i=0;i<POLY_DEGREE;i++) {
ifs->read((char*)&(pk->a)(0,i), sizeof(uint64_t));
}
for (size_t i=0;i<POLY_DEGREE;i++) {
ifs->read((char*)&(pk->b)(0,i), sizeof(uint64_t));
}
for (size_t i=0; i<evk->ell; i++) {
for (size_t j=0; j<POLY_DEGREE; j++) {
ifs->read((char*)&(*(*evk->values+i))(0,j), sizeof(uint64_t));
}
}
pk->a_shoup = nfl::compute_shoup(pk->a);
pk->b_shoup = nfl::compute_shoup(pk->b);
}
void writeLittleEndian(ofstream* ofs, uint64_t v) {
*ofs << setfill('0') << setw(2) << hex << (int) (v&0xFF);
*ofs << setfill('0') << setw(2) << (int) ((v >> 8) & 0xFF);
*ofs << setfill('0') << setw(2) << (int) ((v >> 16) & 0xFF);
*ofs << setfill('0') << setw(2) << (int) ((v >> 24) & 0xFF);
*ofs << setfill('0') << setw(2) << (int) ((v >> 32) & 0xFF);
*ofs << setfill('0') << setw(2) << (int) ((v >> 40) & 0xFF);
*ofs << setfill('0') << setw(2) << (int) ((v >> 48) & 0xFF);
*ofs << setfill('0') << setw(2) << (int) ((v >> 56) & 0xFF);
}
bool isLast(ifstream* ifs) {
ifs->get();
if (ifs->eof())
return true;
ifs->seekg(-1, ifs->cur);
return false;
}
void printUsage(char* filename) {
cerr << "Usage : " << filename << " -f [-d] [-i] VCF_FILE KEYSET_FILE" << endl;
cerr << " Generate SQL insertion query files from VCF file" << endl;
cerr << "Usage : " << filename << " -f [-d] [-i] VCF_FILE" << endl;
cerr << " Generate SQL insertion query files from VCF file" << endl;
cerr << " New keyset and encryption parameters will be generated" << endl;
cerr << "Usage : " << filename << " -u KEYSET_FILE USER_NAME ACCESS_LEVEL" << endl;
cerr << " Create new user, USER_NAME must be username of i2b2" << endl;
}
void generateRandomAlphaNumeric(char* target, int length) {
const char charset[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789~!@#$^*()_+{}[]";
for (int i=0;i<length;i++) {
target[i] = charset[rand()%(sizeof(charset)-1)];
}
target[length] = '\0';
}
c4science · Help