void BlumGoldwasserPublicKey::DEREncode(BufferedTransformation &bt) const { DERSequenceEncoder seq(bt); n.DEREncode(seq); }
bool PubAddr::decodeFromObj(packet_pubkey pubkey) { ustring data; try { data = this->decode(pubkey.encrypted, this->getTagE()); } catch (...) { return false; } unsigned int p = 0; int bitfield = data.getInt32(p); ustring signingKey; signingKey += 0x04; signingKey += data.getUstring(64, p); ustring encryptionKey; encryptionKey += 0x04; encryptionKey += data.getUstring(64, p); int nonce_trials = (int)data.getVarInt_B(p); int extra_bytes = (int)data.getVarInt_B(p); int k = p; int sig_len = (int)data.getVarInt_B(p); ustring sign = data.getUstring(sig_len, p); //checking signature OID CURVE = secp256k1(); AutoSeededRandomPool prng; ECPPoint point; unsigned int i = 1; string xA = signingKey.getString(32, i); string yA = signingKey.getString(32, i); point.identity = false; point.x.Decode((byte*)xA.c_str(), 32); point.y.Decode((byte*)yA.c_str(), 32); ECDSA<ECP, SHA1>::PublicKey publicKey; publicKey.Initialize(CURVE, point); bool res = publicKey.Validate(prng, 3); ECDSA<ECP, SHA1>::Verifier verifier(publicKey); // Result of the verification process bool result = false; ustring mess1; unsigned int j = 8; mess1.appendInt64(pubkey.message_payload.getInt64(j)); mess1.appendInt32(pubkey.message_payload.getInt32(j)); mess1.appendVarInt_B(pubkey.message_payload.getVarInt_B(j)); mess1.appendVarInt_B(pubkey.message_payload.getVarInt_B(j)); mess1 += this->getTag(); string mess; mess += mess1.toString(); j = 0; mess += data.getString(k, j); string tmp_sign = sign.toString(); //BER decoding Integer r, s; StringStore store(tmp_sign); BERSequenceDecoder seq(store); r.BERDecode(seq); s.BERDecode(seq); seq.MessageEnd(); string signature; StringSink sink(signature); r.Encode(sink, 32); s.Encode(sink, 32); //end conversion StringSource sss(signature + mess, true, new SignatureVerificationFilter( verifier, new ArraySink((byte*)&result, sizeof(result)) ) // SignatureVerificationFilter ); if (result) { this->loadKeys(signingKey, encryptionKey, nonce_trials, extra_bytes); return true; } return false; }
BlumGoldwasserPublicKey::BlumGoldwasserPublicKey(BufferedTransformation &bt) { BERSequenceDecoder seq(bt); n.BERDecode(seq); modulusLen = n.ByteCount(); }
bool CsFetcher::saveSlot(Item* item, DBConn* conn) { // usleep(1000000 * 3); CsItem* cItem = (CsItem*)item; CsParam p = cItem->getParam(); QString sql = ""; QSqlQuery q(conn->qtDatabase()); int i = 0; if (p.id != 0) { sql = "UPDATE client_service" " SET" " client_id = ?" ", date = ?" ", summ = ?" ", limit_value = ?" ", limit_days = ?" ", limit_type = ?" ", name = ?" ", vid_id = ?" " WHERE id = ?"; q.prepare(sql); q.bindValue(i++, p.client_id); q.bindValue(i++, p.date); q.bindValue(i++, p.summ); q.bindValue(i++, p.limit_value); q.bindValue(i++, p.limit_days); q.bindValue(i++, p.limit_type); q.bindValue(i++, p.name); q.bindValue(i++, p.vid_id); q.bindValue(i++, p.id); } else { sql = "SELECT nextval('client_service_id_seq')"; QSqlQuery seq(conn->qtDatabase()); seq.exec(sql); if (seq.next()) { qDebug() << "NEW ID = " << seq.value(0).toInt(); p.id = seq.value(0).toInt(); cItem->setParam(p); } sql = "INSERT INTO client_service(" " id, client_id, date, summ, limit_value, limit_days, limit_type, name, vid_id)" " VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?)"; q.prepare(sql); q.bindValue(i++, p.id); q.bindValue(i++, p.client_id); q.bindValue(i++, p.date); q.bindValue(i++, p.summ); q.bindValue(i++, p.limit_value); q.bindValue(i++, p.limit_days); q.bindValue(i++, p.limit_type); q.bindValue(i++, p.name); q.bindValue(i++, p.vid_id); } return conn->executeQuery(q); }
packet_pubkey Addr::encodePubKey() { std::shared_lock<std::shared_timed_mutex> mlock(this->mutex_); packet_pubkey pubkey; time_t ltime = std::time(nullptr); this->lastPubKeyRequest = ltime; std::random_device rd; std::mt19937 engine(rd()); std::uniform_int_distribution<int> distribution(-300, 300); int random = distribution(engine); time_t TTL = 4 * 24 * 60 * 60 + random; //4 days +- 5 min ltime = ltime + TTL; pubkey.objectType = 1; pubkey.Time = ltime; pubkey.stream = this->getStream(); pubkey.version = 4; pubkey.encodePayload(); ustring plain; OID CURVE = secp256k1(); AutoSeededRandomPool rng; ECDH < ECP >::Domain dhA(CURVE); //generating ephemeral key pair SecByteBlock privA(dhA.PrivateKeyLength()), pubA(dhA.PublicKeyLength()); dhA.GenerateKeyPair(rng, privA, pubA); ustring pubEKey; pubEKey.append(pubA.data(), pubA.size()); ustring privEKey; privEKey.append(privA.data(), privA.size()); plain.appendInt32(1); //bitfiled 1 not yet integrated plain.append(this->pubSigningKey.c_str() + 1, 64); plain.append(this->pubEncryptionKey.c_str() + 1, 64); plain.appendVarInt_B(this->nonce_trials); plain.appendVarInt_B(this->extra_bytes); AutoSeededRandomPool prng; ECDSA<ECP, SHA1>::PrivateKey privateKey; Integer x; x.Decode(this->getPrivSigningKey().c_str(), this->getPrivSigningKey().size()); privateKey.Initialize(CURVE, x); ECDSA<ECP, SHA1>::Signer signer(privateKey); string signature; string mess; ustring mess1; unsigned int i = 8; mess1.appendInt64(pubkey.message_payload.getInt64(i)); mess1.appendInt32(pubkey.message_payload.getInt32(i)); mess1.appendVarInt_B(pubkey.message_payload.getVarInt_B(i)); mess1.appendVarInt_B(pubkey.message_payload.getVarInt_B(i)); mess1 += this->getTag(); mess += mess1.toString(); mess += plain.toString(); StringSource ss(mess, true /*pump all*/, new SignerFilter(prng, signer, new StringSink(signature) ) // SignerFilter ); // StringSource //DER encoding Integer r, s; StringStore store(signature); r.Decode(store, signature.size() / 2); s.Decode(store, signature.size() / 2); string sign; StringSink sink(sign); DERSequenceEncoder seq(sink); r.DEREncode(seq); s.DEREncode(seq); seq.MessageEnd(); //end conversion plain.appendVarInt_B(sign.size()); plain.append((unsigned char*)sign.c_str(), sign.size()); ECIES<ECP>::PrivateKey priv; ustring pubK = this->getPubOfPriv(this->getTagE()); //Integer e; //e.Decode(this->getTagE().c_str(), 32); //priv.Initialize(CURVE, e); //ECIES<ECP>::PublicKey pub; //priv.MakePublicKey(pub); //const ECP::Point& qq = pub.GetPublicElement(); //string pubS; //StringSink sinkK(pubS); //qq.x.Encode(sinkK, 32); //qq.y.Encode(sinkK, 32); //ustring pubK; //pubK += 0x04; //pubK.fromString(pubS); ustring encoded = this->encode(pubK, privEKey, pubEKey, plain); pubkey.tag = this->getTag(); pubkey.encrypted = encoded; pubkey.encodeObject(); return pubkey; }
// 4.2.1.12. Extended Key Usage (id-ce-extKeyUsage) // 4.2.1.12. Extended Key Usage (id-ce-extKeyUsage) Result CheckExtendedKeyUsage(EndEntityOrCA endEntityOrCA, const SECItem* encodedEKUs, SECOidTag requiredEKU) { // TODO: Either do not allow anyExtendedKeyUsage to be passed as requiredEKU, // or require that callers pass anyExtendedKeyUsage instead of // SEC_OID_UNKNWON and disallow SEC_OID_UNKNWON. // XXX: We're using SEC_ERROR_INADEQUATE_CERT_TYPE here so that callers can // distinguish EKU mismatch from KU mismatch from basic constraints mismatch. // We should probably add a new error code that is more clear for this type // of problem. bool foundOCSPSigning = false; if (encodedEKUs) { ScopedPtr<CERTOidSequence, CERT_DestroyOidSequence> seq(CERT_DecodeOidSequence(encodedEKUs)); if (!seq) { PR_SetError(SEC_ERROR_INADEQUATE_CERT_TYPE, 0); return RecoverableError; } bool found = false; // XXX: We allow duplicate entries. for (const SECItem* const* oids = seq->oids; oids && *oids; ++oids) { SECOidTag oidTag = SECOID_FindOIDTag(*oids); if (requiredEKU != SEC_OID_UNKNOWN && oidTag == requiredEKU) { found = true; } if (oidTag == SEC_OID_OCSP_RESPONDER) { foundOCSPSigning = true; } } // If the EKU extension was included, then the required EKU must be in the // list. if (!found) { PR_SetError(SEC_ERROR_INADEQUATE_CERT_TYPE, 0); return RecoverableError; } } // pkixocsp.cpp depends on the following additional checks. if (foundOCSPSigning) { // When validating anything other than an delegated OCSP signing cert, // reject any cert that also claims to be an OCSP responder, because such // a cert does not make sense. For example, if an SSL certificate were to // assert id-kp-OCSPSigning then it could sign OCSP responses for itself, // if not for this check. if (requiredEKU != SEC_OID_OCSP_RESPONDER) { PR_SetError(SEC_ERROR_INADEQUATE_CERT_TYPE, 0); return RecoverableError; } } else if (requiredEKU == SEC_OID_OCSP_RESPONDER && endEntityOrCA == MustBeEndEntity) { // http://tools.ietf.org/html/rfc6960#section-4.2.2.2: // "OCSP signing delegation SHALL be designated by the inclusion of // id-kp-OCSPSigning in an extended key usage certificate extension // included in the OCSP response signer's certificate." // // id-kp-OCSPSigning is the only EKU that isn't implicitly assumed when the // EKU extension is missing from an end-entity certificate. However, any CA // certificate can issue a delegated OCSP response signing certificate, so // we can't require the EKU be explicitly included for CA certificates. PR_SetError(SEC_ERROR_INADEQUATE_CERT_TYPE, 0); return RecoverableError; } return Success; }
void PPLMGeneralComparison::do_next (xqp_tuple &t) { if (first_time) { first_time = false; tuple_cell (*comp_op) (const tuple_cell&,const tuple_cell&,CollationHandler*); if (strict) { if (more) comp_op=op_gt; else comp_op=op_lt; } else { if (more) comp_op=op_ge; else comp_op=op_le; } //INSERT CODE HERE if (!eos_reached1) seq1.op->reopen(); if (!eos_reached2) seq2.op->reopen(); eos_reached2 = false; eos_reached1 = false; xqp_tuple cont1(seq1.ts); xqp_tuple cont2(seq2.ts); seq1.op->next(cont1); sequence seq(1); xqp_tuple at_tup(1); seq2.op->next(cont2); if (cont2.is_eos()) { eos_reached2 = true; t.copy(tuple_cell::atomic(false)); return; } tuple_cell res1=getAtomizedCell(cont2); while (!cont1.is_eos()) { tuple_cell res=getAtomizedCell(cont1); at_tup.cells[0]=res; generalNodePrepare(res,res1); if (comp_op(res,res1,handler).get_xs_boolean()) { t.copy(tuple_cell::atomic(true)); return; } seq.add(at_tup); seq1.op->next(cont1); } eos_reached1 = true; if (seq.size()<1) { t.copy(tuple_cell::atomic(false)); return; } seq2.op->next(cont2); while (!cont2.is_eos()) { tuple_cell res1=getAtomizedCell(cont2); sequence::iterator it=seq.begin(); do { tuple_cell res2=(*it).cells[0]; generalNodePrepare(res1,res2); if (comp_op(res2,res1,handler).get_xs_boolean()) { t.copy(tuple_cell::atomic(true)); return; } it++; } while (it!=seq.end()); seq2.op->next(cont2); } eos_reached2 = true; t.copy(tuple_cell::atomic(false)); return; } else { first_time = true; t.set_eos(); } }
int PreClusterCommand::mergeGroupCounts(string newcount, string newname, string newfasta){ try { ifstream inNames; m->openInputFile(newname, inNames); string group, first, second; set<string> uniqueNames; while (!inNames.eof()) { if (m->control_pressed) { break; } inNames >> group; m->gobble(inNames); inNames >> first; m->gobble(inNames); inNames >> second; m->gobble(inNames); vector<string> names; m->splitAtComma(second, names); uniqueNames.insert(first); int total = ct.getGroupCount(first, group); for (int i = 1; i < names.size(); i++) { total += ct.getGroupCount(names[i], group); ct.setAbund(names[i], group, 0); } ct.setAbund(first, group, total); } inNames.close(); vector<string> namesOfSeqs = ct.getNamesOfSeqs(); for (int i = 0; i < namesOfSeqs.size(); i++) { if (ct.getNumSeqs(namesOfSeqs[i]) == 0) { ct.remove(namesOfSeqs[i]); } } ct.printTable(newcount); m->mothurRemove(newname); if (bygroup) { //if by group, must remove the duplicate seqs that are named the same ifstream in; m->openInputFile(newfasta, in); ofstream out; m->openOutputFile(newfasta+"temp", out); int count = 0; set<string> already; while(!in.eof()) { if (m->control_pressed) { break; } Sequence seq(in); m->gobble(in); if (seq.getName() != "") { count++; if (already.count(seq.getName()) == 0) { seq.printSequence(out); already.insert(seq.getName()); } } } in.close(); out.close(); m->mothurRemove(newfasta); m->renameFile(newfasta+"temp", newfasta); } return 0; } catch(exception& e) { m->errorOut(e, "PreClusterCommand", "mergeGroupCounts"); exit(1); } }
operator Sequence<ObjectName<ObjTag>>() const { return seq(); }
bool ChopSeqsCommand::driver(linePair filePos, string filename, string outFasta, string outAccnos, string fastaFileTemp) { try { ofstream out; m->openOutputFile(outFasta, out); ofstream outAcc; m->openOutputFile(outAccnos, outAcc); ofstream outfTemp; if (fastaFileTemp != "") { m->openOutputFile(fastaFileTemp, outfTemp); } ifstream in; m->openInputFile(filename, in); in.seekg(filePos.start); //adjust if (filePos.start == 0) { m->zapGremlins(in); m->gobble(in); } bool done = false; bool wroteAccnos = false; int count = 0; while (!done) { if (m->control_pressed) { in.close(); out.close(); return 1; } Sequence seq(in); m->gobble(in); if (m->control_pressed) { in.close(); out.close(); outAcc.close(); m->mothurRemove(outFasta); m->mothurRemove(outAccnos); if (fastaFileTemp != "") { outfTemp.close(); m->mothurRemove(fastaFileTemp); } return 0; } if (seq.getName() != "") { string qualValues = ""; string newSeqString = getChopped(seq, qualValues); //output trimmed sequence if (newSeqString != "") { out << ">" << seq.getName() << endl << newSeqString << endl; }else{ outAcc << seq.getName() << endl; wroteAccnos = true; } if (fastaFileTemp != "") { outfTemp << qualValues << endl; } count++; } #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix) unsigned long long pos = in.tellg(); if ((pos == -1) || (pos >= filePos.end)) { break; } #else if (in.eof()) { break; } #endif //report progress if((count) % 10000 == 0){ m->mothurOut(toString(count)); m->mothurOutEndLine(); } } //report progress if((count) % 10000 != 0){ m->mothurOut(toString(count)); m->mothurOutEndLine(); } in.close(); out.close(); outAcc.close(); if (fastaFileTemp != "") { outfTemp.close(); } return wroteAccnos; } catch(exception& e) { m->errorOut(e, "ChopSeqsCommand", "driver"); exit(1); } }