bool CryptoECDSA::VerifyData(SecureBinaryData const & binMessage,
SecureBinaryData const & binSignature,
BTC_PUBKEY const & cppPubKey)
{
CryptoPP::SHA256 sha256;
BTC_PRNG prng;
assert(cppPubKey.Validate(prng, 3));
// We execute the first SHA256 op, here. Next one is done by Verifier
SecureBinaryData hashVal(32);
sha256.CalculateDigest(hashVal.getPtr(),
binMessage.getPtr(),
binMessage.getSize());
// Verifying message
BTC_VERIFIER verifier(cppPubKey);
return verifier.VerifyMessage((const byte*)hashVal.getPtr(),
hashVal.getSize(),
(const byte*)binSignature.getPtr(),
binSignature.getSize());
}
extern "C" char *_dll_name(char *name)
{
int hash = hashVal(name);
HASHREC *hr = _using_hash[hash];
while (hr)
{
if (!strcmp(hr->p->name, name))
return ((struct data *)hr->p)->dllName;
hr = hr->next;
}
return NULL;
}
void analyzeFragment(string fragment) {
string first_half = fragment.substr(0, KEY_LENGTH);
string second_half;
string index_string;
int index;
//If the first segment have has bad bp
if (first_half.find('N') != string::npos)
return;
//Iterate all consecutive segments
for (int i = 1; i <= MAX_SEGMENT_NUM_; i++) {
//Iterate In/Dels
for (int j = 0; j <= MAX_INDEL_NUM_; j++) {
//For insertions
second_half = fragment.substr(i * KEY_LENGTH - j, KEY_LENGTH);
if (second_half.find('N') == string::npos) {
index_string = first_half.substr(0, KEY_LENGTH / 2)
+ second_half.substr(0, KEY_LENGTH / 2);
index = hashVal(index_string);
for (int k = j; k <= MAX_INDEL_NUM_; k++) {
friend_hash[index][i][k] = true;
}
}
//For deletions
second_half = fragment.substr(i * KEY_LENGTH + j, KEY_LENGTH);
if (second_half.find('N') == string::npos) {
index_string = first_half.substr(0, KEY_LENGTH / 2)
+ second_half.substr(0, KEY_LENGTH / 2);
index = hashVal(index_string);
for (int k = j; k <= MAX_INDEL_NUM_; k++) {
friend_hash[index][i][k] = true;
}
}
}
}
}
static void hashInsert(struct data *names)
{
int hash = hashVal(names->name);
HASHREC *hr = _using_hash[hash];
while (hr)
{
if (!strcmp(hr->p->name, names->name))
return;
hr = hr->next;
}
hr = (HASHREC *)calloc(1, sizeof(HASHREC));
hr->p = (HASHREC::_hrintern_ *)names;
hr->next = _using_hash[hash];
_using_hash[hash] = hr;
}
/************************************************************************** //Function: DelNode //Description: 删除节点 //Calls: //Called by: //Input: pNode 指向待删除节点的指针 lFlag 1表示删除且需要释放内存 0表示删除但不需要释放内存 //Output: //Return: 返回值 说明 0 成功 负值 失败 //Others: //Author: fanyh Email: [email protected] //Date: 2008-06-16 **************************************************************************/ int DelNode(CMiniCache *cache, CMiniCacheNode *pNode, long lFlag) { if(!pNode) return -1; if(pNode->pLeft && pNode->pRight) { pNode->pLeft->pRight = pNode->pRight; pNode->pRight->pLeft = pNode->pLeft; } else { if(NULL == pNode->pRight) { //m_pHead cache->m_pHead = pNode->pLeft; if(cache->m_pHead) cache->m_pHead->pRight = NULL; } if(NULL == pNode->pLeft) { //m_pEnd cache->m_pEnd = pNode->pRight; if(cache->m_pEnd) cache->m_pEnd->pLeft = NULL; } } size_t pos = hashVal(pNode->tKey, cache->m_lHashSize); if(pNode == cache->m_ppHash[pos]) { cache->m_ppHash[pos] = pNode->pDown; if(pNode->pDown) pNode->pDown->pUp = NULL; } else { if(pNode->pUp) pNode->pUp->pDown = pNode->pDown; if(pNode->pDown) pNode->pDown->pUp = pNode->pUp; } if(lFlag) { if(cache->m_pDataFreeFun && pNode->vpData) { while(cache->m_pDataFreeFun(pNode->vpData)) usleep(100); pNode->vpData = NULL; SYNC_SUB(&cache->lDataSize, pNode->lDataSize); SYNC_SUB(&cache->lDataNum, 1); } pNode->pDown = cache->m_pIdleNode; cache->m_pIdleNode = pNode; } return 0; }
/************************************************************************** //Function: FindNode //Description: 根据关键字查找节点 //Calls: //Called by: //Input: tKey 记录主关键字 //Output: pNode 指向查找到节点的指针 //Return: 返回值 说明 0 成功 负值 失败 //Others: //Author: fanyh Email: [email protected] //Date: 2008-06-16 **************************************************************************/ int FindNode(CMiniCache *cache, map_key_t tKey, CMiniCacheNode **pOldNode) { size_t lPos; if (!pOldNode) return -1; lPos = hashVal(tKey, cache->m_lHashSize); if(cache->m_ppHash[lPos]) { *pOldNode = cache->m_ppHash[lPos]; while(*pOldNode) { if(md5_compare((*pOldNode)->tKey->digest, tKey->digest) == 0) return 0; else *pOldNode = (*pOldNode)->pDown; } } return -1; }
void hashTestFull(char * hash_file_name, char * ref_file_name, char * output_file_name) {
int fragment_pointer;
int fragment_number;
int fragment_coord;
int * index_db;
int * coordinate_db;
char * fragment_seq = (char*) malloc(KEY_LENGTH+1);
char * reconstructed_seq= (char *)malloc(sizeof(char)*KEY_LENGTH);
char * decoded_char = (char *)malloc(sizeof(char)*(KEY_LENGTH+1));
FILE * pFileOut;
fprintf (stdout,"Read Hash Table: %s \n", hash_file_name);
hashReconstructorChar(&index_db, &coordinate_db, hash_file_name);
pFileOut = fopen (output_file_name, "w");
for (int i = 0 ; i < INDEX_NUM ; i++) {
reconstructSeq(decoded_char, i);
fragment_pointer = index_db[hashVal(decoded_char)];
fragment_number = coordinate_db[fragment_pointer];
if (fragment_number != 0 ){
fprintf (pFileOut,"\nseq %s: pointer %i: frag# %i---->", decoded_char, fragment_pointer, fragment_number);
}
for (int j = 0 ; j < fragment_number ; j++) {
fragment_coord = coordinate_db[fragment_pointer+1+j];
getRefSeq(fragment_seq, fragment_coord, KEY_LENGTH, REF_TABLE_SIZE);
if (strncmp(fragment_seq, decoded_char, KEY_LENGTH) == 0) {
fprintf (pFileOut,"_P%i", j);
} else {
fprintf (pFileOut,"_F%i(%i/%s)", j, fragment_coord, fragment_seq);
}
}
}
fclose(pFileOut);
// free allocated memory
free(fragment_seq);
free(reconstructed_seq);
free(decoded_char);
}
/**************************************************************************
//Function: __AddNode
//Description: 加入关键字节点
//Calls:
//Called by:
//Input:
pNode 指向待加入节点的指针
//Output:
//Return:
返回值 说明
0 成功
负值 失败
//Others:
//Author: fanyh Email: [email protected]
//Date: 2008-06-16
**************************************************************************/
static inline int
__AddNode(CMiniCache *cache, CMiniCacheNode* pNode, bool readd)
{
size_t lPos;
lPos = hashVal(pNode->tKey, cache->m_lHashSize);
//放到hash位置
if(cache->m_ppHash[lPos]) {
pNode->pDown = cache->m_ppHash[lPos];
pNode->pUp = NULL;
cache->m_ppHash[lPos]->pUp = pNode;
cache->m_ppHash[lPos] = pNode;
} else {
pNode->pDown = NULL;
pNode->pUp = NULL;
cache->m_ppHash[lPos] = pNode;
}
//使用链表，left是更加新的
if(cache->m_pEnd) {
pNode->pRight = cache->m_pEnd;
pNode->pLeft = NULL;
cache->m_pEnd->pLeft = pNode;
cache->m_pEnd = pNode;
} else {
pNode->pRight = NULL;
pNode->pLeft = NULL;
cache->m_pEnd = pNode;
}
if(!cache->m_pHead)
cache->m_pHead = pNode;
if (!readd) {
SYNC_ADD(&cache->lDataSize, pNode->lDataSize);
SYNC_ADD(&cache->lDataNum, 1);
}
return 0;
}
/////////////////////////////////////////////////////////////////////////////
// Use the secp256k1 curve to sign data of an arbitrary length.
// Input: Data to sign (const SecureBinaryData&)
// The private key used to sign the data (const BTC_PRIVKEY&)
// A flag indicating if deterministic signing is used (const bool&)
// Output: None
// Return: The signature of the data (SecureBinaryData)
SecureBinaryData CryptoECDSA::SignData(SecureBinaryData const & binToSign,
BTC_PRIVKEY const & cppPrivKey,
const bool& detSign)
{
// We trick the Crypto++ ECDSA module by passing it a single-hashed
// message, it will do the second hash before it signs it. This is
// exactly what we need.
CryptoPP::SHA256 sha256;
BTC_PRNG prng;
// Execute the first sha256 op -- the signer will do the other one
SecureBinaryData hashVal(32);
sha256.CalculateDigest(hashVal.getPtr(),
binToSign.getPtr(),
binToSign.getSize());
// Do we want to use a PRNG or use deterministic signing (RFC 6979)?
string signature;
if(detSign)
{
BTC_DETSIGNER signer(cppPrivKey);
CryptoPP::StringSource(
hashVal.toBinStr(), true, new CryptoPP::SignerFilter(
prng, signer, new CryptoPP::StringSink(signature)));
}
else
{
BTC_SIGNER signer(cppPrivKey);
CryptoPP::StringSource(
hashVal.toBinStr(), true, new CryptoPP::SignerFilter(
prng, signer, new CryptoPP::StringSink(signature)));
}
return SecureBinaryData(signature);
}
SecureBinaryData CryptoECDSA::SignData(SecureBinaryData const & binToSign,
BTC_PRIVKEY const & cppPrivKey)
{
// We trick the Crypto++ ECDSA module by passing it a single-hashed
// message, it will do the second hash before it signs it. This is
// exactly what we need.
static CryptoPP::SHA256 sha256;
static BTC_PRNG prng;
// Execute the first sha256 op -- the signer will do the other one
SecureBinaryData hashVal(32);
sha256.CalculateDigest(hashVal.getPtr(),
binToSign.getPtr(),
binToSign.getSize());
string signature;
BTC_SIGNER signer(cppPrivKey);
CryptoPP::StringSource(
hashVal.toBinStr(), true, new CryptoPP::SignerFilter(
prng, signer, new CryptoPP::StringSink(signature)));
return SecureBinaryData(signature);
}
void *preProcessReads(int *idp)
{
int id = *idp;
int i=0, j=0, pos=0, tmpSize=0;
int32_t hvtmp, cstmp;
int div = _r_seqCnt / THREAD_COUNT;
div += (_r_seqCnt % THREAD_COUNT)?1:0;
Pair *tmp = getMem(sizeof(Pair)*(div * _r_samplingLocsSize*2));
char alphCnt[5];
char *a, *b;
for (i=id*div; i<div*(id+1) && i<_r_seqCnt; i++)
{
alphCnt[0]=alphCnt[1]=alphCnt[2]=alphCnt[3]=alphCnt[4]=0;
a = _r_seq[i].seq;
b = _r_seq[i].rseq+SEQ_LENGTH;
*(b--)='\0';
for (j = 0; j<SEQ_LENGTH; j++)
{
*a = toupper(*a);
*b = reverseCompleteChar(*a);
alphCnt[_r_alphIndex[*a]]++;
a++;
b--;
}
if (alphCnt[4]>errThreshold)
_r_seq[i].hits[0]=1;
_r_seq[i].alphCnt[0] = alphCnt[0];
_r_seq[i].alphCnt[1] = alphCnt[1];
_r_seq[i].alphCnt[2] = alphCnt[2];
_r_seq[i].alphCnt[3] = alphCnt[3];
compressSequence(_r_seq[i].seq, SEQ_LENGTH, _r_seq[i].cseq);
compressSequence(_r_seq[i].rseq, SEQ_LENGTH, _r_seq[i].crseq);
if (_r_seq[i].hits[0] == 1) // marked reads are not indexed
{
_r_seq[i].hits[0] = 0;
for (j=0; j< 2*_r_samplingLocsSize; j++)
{
tmp[pos].hv = -1;
tmp[pos].checksum = 0;
tmp[pos].seqInfo = pos +(div*id*2*_r_samplingLocsSize);
pos++;
}
}
else
{
for (j=0; j< _r_samplingLocsSize; j++)
{
hvtmp = hashVal(_r_seq[i].seq+_r_samplingLocs[j]);
cstmp = checkSumVal(_r_seq[i].seq+_r_samplingLocs[j]+WINDOW_SIZE);
if (hvtmp == -1 || cstmp == -1)
{
tmp[pos].hv = -1;
tmp[pos].checksum = 0;
}
else
{
tmp[pos].hv = hvtmp;
tmp[pos].checksum = cstmp;
}
tmp[pos].seqInfo = pos +(div*id*2*_r_samplingLocsSize);
pos++;
}
for (j=0; j<_r_samplingLocsSize; j++)
{
hvtmp = hashVal(_r_seq[i].rseq+_r_samplingLocs[j]);
cstmp = checkSumVal(_r_seq[i].rseq+_r_samplingLocs[j]+WINDOW_SIZE);
if (hvtmp == -1 || cstmp == -1)
{
tmp[pos].hv = -1;
tmp[pos].checksum = 0;
}
else
{
tmp[pos].hv = hvtmp;
tmp[pos].checksum = cstmp;
}
tmp[pos].seqInfo = pos+(div*id*2*_r_samplingLocsSize);
pos++;
}
}
tmpSize+=2*_r_samplingLocsSize;
}
introSortPair( tmp, 0, tmpSize-1);
int uniq = 0;
int prev = -2;
int beg = -1;
int end = -1;
for (i=0; i<tmpSize; i++)
{
if (prev != tmp[i].hv)
{
uniq ++;
prev = tmp[i].hv;
}
}
_r_readIndexSize[id] = uniq;
_r_readIndex[id] = getMem(sizeof(ReadIndexTable)*_r_readIndexSize[id]);
prev = -2;
j=0;
beg =0;
while (beg < tmpSize)
{
end = beg;
while (end+1<tmpSize && tmp[end+1].hv==tmp[beg].hv)
end++;
_r_readIndex[id][j].hv = tmp[beg].hv;
_r_readIndex[id][j].list = getMem(sizeof(GeneralIndex)*(end-beg+2));
_r_readIndex[id][j].list[0].info = end-beg+1;
for (i=1; i <= _r_readIndex[id][j].list[0].info; i++)
{
_r_readIndex[id][j].list[i].info=tmp[beg+i-1].seqInfo;
_r_readIndex[id][j].list[i].checksum=tmp[beg+i-1].checksum;
}
j++;
beg = end+1;
}
freeMem(tmp, sizeof(Pair)*(div*_r_samplingLocsSize*2));
return NULL;
}
void hashTableGenerator(string ref_name) {
//Open and read the reference file
ifstream ref_file;
deque<int>::iterator iter;
int coor_counter = KEY_LENGTH*(-1);
int flag_ignore = 0;
int monitor_counter = 0; // For operation monitoring
int monitor_counter2 = 0; // For operation monitoring
ref_file.open(ref_name.c_str());
if (!ref_file.good()) {
cerr << "reference file cannot open." << endl;
exit(1);
}
//cout << "Hello0" << endl;
//Initialize hash_table.
// hash_table.resize(1 << (2 * KEY_LENGTH) );
// hash_table_counter = 0;
//cout << "Hello1" << endl;
//Read in the first key
char temp_key[KEY_LENGTH + 1];
char temp_char;
string keystr(KEY_LENGTH, 'A');
//cout << "keystr: " << keystr << endl;
//throw out the first several Ns
do {
ref_file >> temp_char;
coor_counter++;
//cout << "coor_counter: " << coor_counter << endl;
} while (temp_char == 'N');
//update the first non N character
temp_key[0] = temp_char;
//cout << "temp_char: " << temp_char << endl;
//Read the first 12 characters
for (int i = 1; i < KEY_LENGTH; i++) {
//cout << "i: " << i << endl;
ref_file >> temp_char;
coor_counter++;
//cout << "coor_counter: " << coor_counter << endl;
temp_key[i] = temp_char;
//Check if the file is too short
if (ref_file.eof()) {
cerr << "file too short";
exit(1);
}
//Check if next N come too close
if (temp_char == 'N') {
cerr << "Too short useful String A" << endl;
exit(1);
}
}
temp_key[KEY_LENGTH] = '\0';
keystr = temp_key;
//cout << "temp_key: " << temp_key << endl;
//cout << "keystr: " << keystr << endl;
//Read the ref file until the end of file.
do {
//Compute idx and hash_value
if (flag_ignore == 0) {
int hash_value = hashVal(keystr);
//cout << "hash_value: " << hash_value << endl;
//Add to hash_table
//cout << "coor_counter: " << coor_counter << endl;
hash_table[hash_value].push_front(coor_counter);
hash_table_counter++;
} else {
flag_ignore = 0;
for (int i = 0; i < KEY_LENGTH; i++ ) {
if (keystr[i] == 'N') {
flag_ignore = 1;
}
}
if (flag_ignore == 0) {
int hash_value = hashVal(keystr);
//hash_table[hash_value].push_front(coor_counter);
//hash_table_counter++;
}
}
/*
//Add to hash_table list
if (hash_table[idx][hash_value].size() == 0) {
//cout << "first saw" << endl;
hash_table[idx][hash_value].push_back(counter);
}
else {
iter = hash_table[idx][hash_value].begin();
while (iter != hash_table[idx][hash_value].end() && counter > *iter) {
//cout << "*iter: " << *iter << endl;
iter++;
}
hash_table[idx][hash_value].insert(iter, counter);
}
*/
//Read next character
ref_file >> temp_char;
//Increment counter
coor_counter++;
bool fresh_start = false; //indicater for a new start after large area of N
//If enters N area, throw them away
while (temp_char == 'N') {
if (ref_file.eof() ) {
ref_file.close();
return;
}
fresh_start = true;
ref_file >> temp_char;
coor_counter++;
//cout << "coor_counter: " << coor_counter << endl;
}
if (fresh_start) {
//cout << "In a fresh start!" << endl;
keystr[0] = temp_char;
for (int i = 1; i < KEY_LENGTH; i++) {
//cout << 'i' << i << endl;
ref_file >> temp_char;
coor_counter++;
//cout << "coor_counter: " << coor_counter << endl;
//Check if next N come too close
if (temp_char == 'N') {
cerr << "Too short useful String B" << endl;
flag_ignore = 1;
//exit(1);
}
keystr[i] = temp_char;
}
} else
keystr = keystr.substr(1, KEY_LENGTH - 1) + temp_char;
//cout << "keystr: " << keystr << endl;
// add process monitoring loop
monitor_counter = monitor_counter +1; // For operation monitoring
monitor_counter2 = monitor_counter2 +1;
if (monitor_counter >= 1000000) {
cout << "hash generator: " << monitor_counter2 << endl;
monitor_counter = 0;
}
} while (ref_file.good());
