C++ Hash::ComputeHash方法代码示例

  void BulkRound::CreateDescriptor(const QByteArray &data)
  {
    int length = data.size();

    Hash hashalgo;

    QByteArray xor_message(length, 0);
    QVector<QByteArray> hashes;

    int my_idx = GetGroup().GetIndex(GetLocalId());

    foreach(const PublicIdentity &gc, GetGroup().GetRoster()) {
      QByteArray seed = _anon_dh.GetSharedSecret(gc.GetDhKey());

      if(hashes.size() == my_idx) {
        hashes.append(QByteArray());
        continue;
      }

      QByteArray msg(length, 0);
      CryptoRandom(seed).GenerateBlock(msg);
      hashes.append(hashalgo.ComputeHash(msg));
      Xor(xor_message, xor_message, msg);
    }

    QByteArray my_xor_message = QByteArray(length, 0);
    Xor(my_xor_message, xor_message, data);
    SetMyXorMessage(my_xor_message);
    hashes[my_idx] = hashalgo.ComputeHash(my_xor_message);

    QByteArray hash = hashalgo.ComputeHash(data);

    Descriptor descriptor(length, _anon_dh.GetPublicComponent(), hashes, hash);
    SetMyDescriptor(descriptor);
  }

CompositeIntegerGroup::CompositeIntegerGroup(Integer n) :
    _n(n)
{
    // We pick the generator deterministically n
    Hash *hash = CryptoFactory::GetInstance().GetLibrary()->GetHashAlgorithm();
    QByteArray seed = hash->ComputeHash(n.GetByteArray());

    for(_s=3; ; _s = _s+1) {
        if(!_s.IsPrime()) continue;
        _p = (2 * _s * _n) + 1;

        if(_p.IsPrime()) break;
    }

    // Set g to some random element

    Integer g, h;
    const Integer e_test = 2*_s;
    for(Integer i=0; ; i = i+1) {
        h = (Integer(seed) + i) % _p;

        // Make sure that g generates a subgroup that is bigger
        // than order 2 and s and smaller than order P.
        // Since we do not know the factorization of n=qr,
        // we might be generating a subgroup of order q or r.
        if((g = h.Pow(e_test, _p)) != 1) break;
    }

    _g = Element(new IntegerElementData(g));

    /*
    qDebug() << "_p" << _p.GetByteArray().toHex();
    qDebug() << "_s" << _s.GetByteArray().toHex();
    */
};

  QByteArray BulkRound::ProcessMessage(int des_idx, int msg_index)
  {
    int count = _messages.size();
    const Descriptor &des = GetDescriptors()[des_idx];
    int length = des.Length();
    QByteArray msg(length, 0);

    Hash hashalgo;
    bool good = true;

    for(int idx = 0; idx < count; idx++) {
      const char *tmsg = _messages[idx].constData() + msg_index;
      QByteArray xor_msg(QByteArray::fromRawData(tmsg, length));

      if(des.XorMessageHashes()[idx] != hashalgo.ComputeHash(xor_msg)) {
        qWarning() << "Xor message does not hash properly";
        _bad_message_hash.append(BadHash(des_idx, idx));
        good = false;
      }

      if(good) {
        Xor(msg, msg, xor_msg);
      }
    }

    if(good) {
      return msg;
    } else {
      return QByteArray();
    }
  }

QByteArray IBEPrivateKey::Decrypt(const QByteArray &data) const
{
    QDataStream stream(data);

    //Receive the data and split it into three pieces
    QByteArray Ureceive;
    QByteArray Vreceive;
    QByteArray Wreceive;

    stream>>Ureceive>>Vreceive>>Wreceive;
    QByteArray Sigma;
    QByteArray M;

    Element U=this->_sysparam.GetGroup1()->ElementFromByteArray(Ureceive);
    //If U is not a element of Gourp1 then reject the ciphertext
    if(!this->_sysparam.GetGroup1()->IsElement(U)){
        return QByteArray();
    }

    Element PairDidU=this->_sysparam.GetGroupT()->ApplyPairing(this->_privatekey,U);
    QByteArray GTDidU=this->_sysparam.GetGroupT()->ElementToByteArray(PairDidU);
    Hash *hash = CryptoFactory::GetInstance().GetLibrary()->GetHashAlgorithm();
    //Get H2(e(dID,U))
    QByteArray HashGTDidU = hash->ComputeHash(GTDidU);

    Sigma = Utils::IBEUtils::calculateXor(Vreceive,HashGTDidU);
    //H4(sigma)
    QByteArray HashSigma = hash->ComputeHash(Sigma);
     //Get Message M
    M = Utils::IBEUtils::calculateXor(Wreceive,HashSigma);
    QByteArray hashSigmaM = Sigma;
    hashSigmaM.append(M);

    Integer r = Utils::IBEUtils::HashToZr(this->_sysparam.GetGroup1()->GetOrder(),hashSigmaM);
    Element generator = this->_sysparam.GetGroup1()->GetGenerator();

    if(U!= this->_sysparam.GetGroup1()->Exponentiate(generator,r)){
       return QByteArray();
     }
    free(hash);
     return M;
}

  void BulkRound::HandleAggregatedBulkData(QDataStream &stream, const Id &from)
  {
    if(from == GetLocalId()) {
      return;
    }

    qDebug() << GetGroup().GetIndex(GetLocalId()) << GetLocalId().ToString() <<
      ": received aggregated bulk data from " << GetGroup().GetIndex(from) <<
      from.ToString();

    if(GetGroup().GetLeader() != from) {
      throw QRunTimeError("Received aggregated bulk data from non-leader.");
    }

    if(_state != ReceivingLeaderData) {
      throw QRunTimeError("Not expected at this time.");
    }

    QVector<QByteArray> cleartexts;
    stream >> cleartexts;

    const QVector<Descriptor> &des = GetDescriptors();

    if(cleartexts.count() != des.count()) {
      throw QRunTimeError("Cleartext count does not match descriptor count: " +
          QString::number(cleartexts.count()) + " " +
          QString::number(des.count()));
    }

    Hash hashalgo;

    for(int idx = 0; idx < cleartexts.count(); idx++) {
      QByteArray cleartext = cleartexts[idx];
      QByteArray hash = hashalgo.ComputeHash(cleartext);
      if(hash != des[idx].CleartextHash()) {
        throw QRunTimeError("Cleartext hash does not match descriptor hash.");
      }
      if(!cleartext.isEmpty()) {
        PushData(GetSharedPointer(), cleartext);
      }
    }

    Finish();
  }

  void BulkRound::PrepareBlameShuffle()
  {
    QSharedPointer<Network> net(GetNetwork()->Clone());
    QVariantHash headers = net->GetHeaders();
    headers["bulk"] = false;
    net->SetHeaders(headers);

    Hash hashalgo;
    QByteArray roundid = GetRoundId().GetByteArray();
    roundid = hashalgo.ComputeHash(roundid);
    roundid = hashalgo.ComputeHash(roundid);
    Id sr_id(roundid);

    _shuffle_round = _create_shuffle(GetGroup(), GetPrivateIdentity(), sr_id, net,
        _get_blame_data);

    _shuffle_round->SetSink(&_shuffle_sink);

    QObject::connect(_shuffle_round.data(), SIGNAL(Finished()),
        this, SLOT(BlameShuffleFinished()));
  }

  void BulkRound::ProcessBlame(const QVector<BlameEntry> blame_vector)
  {
    Hash hashalgo;

    foreach(const BlameEntry &be, blame_vector) {
      if(!_bad_message_hash.contains(BadHash(be.first, be.second))) {
        qDebug() << "No knowledge of blame:" << be.first << be.second;
        continue;
      }

      const Descriptor &des = _descriptors[be.first];
      QByteArray msg(des.Length(), 0);
      CryptoRandom(be.third).GenerateBlock(msg);

      QByteArray hash = hashalgo.ComputeHash(msg);
      if(hash == des.XorMessageHashes()[be.second] && !_bad_members.contains(be.second)) {
        qDebug() << "Blame verified for" << be.first << be.second;
        _bad_members.append(be.second);
      } else {
        qDebug() << "Blame could not be verified for" << be.first << be.second;
      }
    }
  }

int main(int argc, char **argv)
{
  QCoreApplication qca(argc, argv);
  QStringList args = QCoreApplication::arguments();

  Settings settings = Settings::CommandLineParse(args);
  if(settings.Help || !settings.IsValid()) {
    QTextStream qtout(stdout, QIODevice::WriteOnly);
    qtout << "usage: " << args[0] << " [options] [settings.conf]\n\n";
    qtout << "options:\n";
    qtout << Settings::GetUsage() << "\n";
    if(!settings.Help) {
      qtout << "error: " << settings.GetError() << "\n\n";
    }
    return -1;
  }
  Settings::ApplicationSettings = settings;

  QList<QSharedPointer<Node> > nodes;

  QSharedPointer<ISink> default_sink(new DummySink());
  QSharedPointer<SinkMultiplexer> app_sink(new SinkMultiplexer());

  QSharedPointer<CommandLine> commandline;
  QSharedPointer<SignalSink> signal_sink(new SignalSink());
  app_sink->AddSink(signal_sink.data());

  QSharedPointer<KeyShare> keys(new KeyShare(settings.PublicKeys));
  Hash hashalgo;
  foreach(const Id &server, settings.ServerIds) {
    QString serv = server.ToString();
    if(!keys->Contains(serv)) {
      qFatal("Missing key for %s", serv.toLatin1().data());
    }
    Q_ASSERT(Id(hashalgo.ComputeHash(keys->GetKey(serv)->GetByteArray())) == server);
  }

  QList<Address> local_end_points = settings.LocalEndPoints;

  for(int idx = 0; idx < settings.LocalNodeCount; idx++) {
    Id local_id = idx < settings.LocalId.count() ? settings.LocalId[idx] : Id();
    QSharedPointer<AsymmetricKey> key;

    QString key_path = settings.PrivateKeys + "/" + local_id.ToString();
    QFile key_file(key_path);
    if(key_file.exists()) {
      key = QSharedPointer<AsymmetricKey>(new DsaPrivateKey(key_path));
    } else {
      QByteArray id = local_id.GetByteArray();
      key = QSharedPointer<AsymmetricKey>(new DsaPrivateKey(id, true));
    }

    QSharedPointer<ISink> nsink = (idx == 0) ? app_sink.dynamicCast<ISink>() : default_sink;
    QSharedPointer<Overlay> overlay(new Overlay(local_id, local_end_points,
          settings.RemoteEndPoints, settings.ServerIds));
    overlay->SetSharedPointer(overlay);

    CreateRound create_round = RoundFactory::GetCreateRound(settings.RoundType);
    QSharedPointer<Session> session;
    if(settings.ServerIds.contains(local_id)) {
      session = MakeSession<ServerSession>(overlay, key, keys, create_round);
    } else {
      session = MakeSession<ClientSession>(overlay, key, keys, create_round);
    }
    session->SetSink(nsink.data());
    QSharedPointer<Node> node(new Node(key, keys, overlay, nsink, session));
    nodes.append(node);

    for(int idx = 0; idx < local_end_points.count(); idx++) {
      local_end_points[idx] = AddressFactory::GetInstance().
        CreateAny(local_end_points[idx].GetType());
    }
  }

  QScopedPointer<WebServer> ws;
//  QScopedPointer<SessionEntryTunnel> tun_entry;
//  QScopedPointer<SessionExitTunnel> tun_exit;

  if(settings.Console) {
    commandline = QSharedPointer<CommandLine>(new CommandLine(nodes));
    QObject::connect(&qca, SIGNAL(aboutToQuit()), commandline.data(), SLOT(Stop()));
    commandline->Start();
    app_sink->AddSink(commandline.data());
  }

  if(settings.WebServer) {
    ws.reset(new WebServer(settings.WebServerUrl));

    /* Stop Web server when application is about to quit */
    QObject::connect(&qca, SIGNAL(aboutToQuit()), ws.data(), SLOT(Stop()));

    /* When the web server stops, quit the application */
    QObject::connect(ws.data(), SIGNAL(Stopped()), &qca, SLOT(quit()));

    QSharedPointer<GetMessagesService> get_messages(new GetMessagesService());
    QObject::connect(signal_sink.data(), SIGNAL(IncomingData(const QByteArray&)),
        get_messages.data(), SLOT(HandleIncomingMessage(const QByteArray&)));
    ws->AddRoute(QHttpRequest::HTTP_GET, "/session/messages", get_messages);

    QSharedPointer<GetFileService> get_webpage(new GetFileService("index.html"));
//.........这里部分代码省略.........