Пример #1
0
int CLuaFunctionDefs::PregMatch ( lua_State* luaVM )
{
    //  table pregMatch ( string base, string pattern, uint flags/string = 0, int maxResults = 100000 )
    SString strBase, strPattern;
    pcrecpp::RE_Options pOptions;
    int iMaxResults;

    CScriptArgReader argStream ( luaVM );
    argStream.ReadString ( strBase );
    argStream.ReadString ( strPattern );
    ReadPregFlags ( argStream, pOptions );
    argStream.ReadNumber ( iMaxResults, 100000 );

    if ( !argStream.HasErrors () )
    {
        lua_newtable ( luaVM );

        pcrecpp::RE pPattern ( strPattern, pOptions );

        pcrecpp::StringPiece strInput ( strBase );

        string strGet; int i = 1;
        while ( pPattern.FindAndConsume ( &strInput, &strGet ) && i <= iMaxResults )
        {
            lua_pushnumber ( luaVM, i );
            lua_pushstring ( luaVM, strGet.c_str () );
            lua_settable ( luaVM, -3 );
            i++;
        }

        return 1;
    }
    else
        m_pScriptDebugging->LogCustom ( luaVM, argStream.GetFullErrorMessage () );

    lua_pushboolean ( luaVM, false );
    return 1;
}
Пример #2
0
struct TempInfo inputTempInfo( struct TempInfo info )
{	
	//Clear buffer.
	char temp;
	while( (temp = getchar()) != '\n' && temp != EOF );
	
	//Get the city.
	printf("Please enter the city name.\n");
	strInput( info.city, CITY_STRING_LENGTH );	
	 
	//Get day.
	printf("Please enter the day.\n");	
	info.day = intInput( DAY_MIN, DAY_MAX );	
	
	//Get the temperature.
	printf("Please enter the temperature.\n");
	info.tempFahr = doubleInput();

	//Convert Fahrenheit to Celsius.
	info.tempCels =  convertFahrToCels(info.tempFahr);

	return info;
}
Пример #3
0
void DlgDecrypt::on_pushButtonDecrypt_clicked()
{
    bool bSuccessDecrypting = false;
    bool bSuccessVerifying  = false;

    QString qstrNymWhoDecrypted;
    QString qstrNymWhoVerified;

    QString qstrText = ui->plainTextEdit->toPlainText().trimmed();
    // --------------------------------
    if (qstrText.isEmpty())
    {
        // pop up a message box warning that the input text is empty.
        //
        QMessageBox::warning(this, tr("Ciphertext is Empty"),
                             tr("Please paste something to be decrypted/verified."));
        return;
    }
    // --------------------------------
    else //qstrText not empty.
    {
        std::string str_input(qstrText.toStdString());
        opentxs::String    strInput (str_input.c_str());

        if (strInput.Exists())
        {
            if (strInput.Contains("-----BEGIN OT ARMORED ENVELOPE-----"))
            {
                opentxs::OTEnvelope theEnvelope;

                if (theEnvelope.SetFromBookendedString(strInput))
                {
                    opentxs::String strOutput;
                    // -------------------------
                    // First we'll try the default nym, if one is available.
                    //
                    QString qstrTempID = Moneychanger::It()->get_default_nym_id();

                    if (!qstrTempID.isEmpty()) // Default Nym IS available.
                    {
                        std::string  str_nym    (qstrTempID.toStdString());
                        opentxs::String     strNym     (str_nym.c_str());
                        opentxs::Identifier nym_id     (strNym);

                        if (!nym_id.IsEmpty())
                        {
                            opentxs::OTPasswordData thePWData("Recipient passphrase");

                            opentxs::Nym * pNym = opentxs::OTAPI_Wrap::OTAPI()->GetOrLoadPrivateNym(nym_id,
                                                                                   false, //bChecking=false
                                                                                   __FUNCTION__,
                                                                                   &thePWData);
                            if (NULL != pNym)
                            {
                                if (theEnvelope.Open(*pNym, strOutput) && strOutput.Exists())
                                {
                                    bSuccessDecrypting = true;
                                    qstrNymWhoDecrypted = qstrTempID;

                                    strInput  = strOutput;
                                    str_input = strInput.Get();
                                    qstrText  = QString::fromStdString(str_input);
                                }
                            }
                        }
                    }
                    // ------------
                    if (!bSuccessDecrypting) // Default nym is NOT available. Okay let's loop through all the Nyms in the wallet then, and try then all...
                    {
                        const int32_t nym_count = opentxs::OTAPI_Wrap::It()->GetNymCount();
                        // -----------------------------------------------
                        for (int32_t ii = 0; ii < nym_count; ++ii)
                        {
                            //Get OT Nym ID
                            QString OT_nym_id = QString::fromStdString(opentxs::OTAPI_Wrap::It()->GetNym_ID(ii));

                            if (!OT_nym_id.isEmpty())
                            {
                                std::string         str_nym    (OT_nym_id.toStdString());
                                opentxs::String     strNym     (str_nym.c_str());
                                opentxs::Identifier nym_id     (strNym);

                                if (!nym_id.IsEmpty())
                                {
                                    opentxs::OTPasswordData thePWData("Recipient passphrase");

                                    opentxs::Nym * pNym = opentxs::OTAPI_Wrap::OTAPI()->GetOrLoadPrivateNym(nym_id,
                                                                                           false, //bChecking=false
                                                                                           "DlgEncrypt::on_pushButtonDecrypt_clicked",
                                                                                           &thePWData);
                                    if (NULL != pNym)
                                    {
                                        // Okay there is a private key available for this Nym, so let's
                                        // try to open the envelope using it.
                                        //
                                        if (theEnvelope.Open(*pNym, strOutput) && strOutput.Exists())
                                        {
                                            bSuccessDecrypting = true;
                                            qstrNymWhoDecrypted = OT_nym_id;

                                            strInput  = strOutput;
                                            str_input = strInput.Get();
                                            qstrText  = QString::fromStdString(str_input);

                                            break;
                                        }
                                    }
                                }
                                // ------------
                            }
                        } // for
                    } // else default nym not available.
                    // -----------------------
                    if (!bSuccessDecrypting)
                    {
                        QMessageBox::warning(this, tr("Failed Decrypting"),
                                             tr("None of the identities in your wallet (including your default identity, "
                                                "if applicable) were able to open this message."));
                        return;

                    }
                    // -----------------------
                } // if (theEnvelope.SetFromBookendedString(strInput))

            } // if (strInput.Contains("-----BEGIN OT ARMORED ENVELOPE-----"))
            // --------------------------------------------
            // This call to DecodeIfArmored is what handles the: "-----BEGIN OT ARMORED ... -----"

            if (strInput.DecodeIfArmored(false)) // bEscapedIsAllowed=true by default.
            {
                std::string str_decoded(strInput.Get());
                QString qstrDecoded(QString::fromStdString(str_decoded));

                if (!qstrDecoded.isEmpty())
                    qstrText = qstrDecoded;
                // -----------------------------------
                // At this point, we know it's been decrypted, if applicable, and it's been
                // de-armored, if applicable. So now we check to see if it's a signed file.
                //
                if (strInput.Contains("-----BEGIN SIGNED FILE-----"))
                {
                    opentxs::OTSignedFile theSignedFile;

                    if (theSignedFile.LoadContractFromString(strInput))
                    {
                        opentxs::String strSignerNymID = theSignedFile.GetSignerNymID();
                        std::string str_signer_nym(strSignerNymID.Get());
                        QString qstrSignerNym(QString::fromStdString(str_signer_nym));

                        if (!str_signer_nym.empty())
                        {
                            opentxs::OTPasswordData thePWData("Sometimes need to load private part of nym in order to use its public key. (Fix that!)");
                            opentxs::Identifier id_signer_nym(strSignerNymID);
                            const opentxs::Nym * pNym = opentxs::OTAPI_Wrap::OTAPI()->GetOrLoadNym(id_signer_nym,
                                                                                   false, //bChecking=false
                                                                                   __FUNCTION__,
                                                                                   &thePWData);
                            if (NULL != pNym)
                            {
                                if (theSignedFile.VerifySignature(*pNym, &thePWData))
                                {
                                    bSuccessVerifying = true;
                                    qstrNymWhoVerified = qstrSignerNym;

                                    opentxs::String strContents = theSignedFile.GetFilePayload();

                                    if (strContents.Exists())
                                    {
                                        strInput  = strContents;
                                        str_input = strInput.Get();
                                        qstrText  = QString::fromStdString(str_input);
                                    }
                                } // signature verified
                            } // pNym exists
                        } // if str_signer_nym exists
                    } // signed file: load contract from string.
                } // "BEGIN SIGNED FILE"
            } // Decode If Armored.
            // -----------------------------------------------
            // if qstrText still contains something, pop up a dialog to display the result to the user.
            //
            if (!qstrText.isEmpty())
            {
                MTNameLookupQT theLookup;
                QString qstrNymWhoDecryptedName(""), qstrNymWhoVerifiedName("");

                if (!qstrNymWhoDecrypted.isEmpty())
                    qstrNymWhoDecryptedName = QString::fromStdString(theLookup.GetNymName(qstrNymWhoDecrypted.toStdString(), ""));
                if (!qstrNymWhoVerified.isEmpty())
                    qstrNymWhoVerifiedName = QString::fromStdString(theLookup.GetNymName(qstrNymWhoVerified.toStdString(), ""));
                // -------------------------------
                if (qstrNymWhoDecryptedName.isEmpty())
                    qstrNymWhoDecryptedName = qstrNymWhoDecrypted;
                else if (qstrNymWhoDecryptedName != qstrNymWhoDecrypted)
                    qstrNymWhoDecryptedName += QString(" (%1)").arg(qstrNymWhoDecrypted);
                // -------------------------------
                if (qstrNymWhoVerifiedName.isEmpty())
                    qstrNymWhoVerifiedName = qstrNymWhoVerified;
                else if (qstrNymWhoVerifiedName != qstrNymWhoVerified)
                    qstrNymWhoVerifiedName += QString(" (%1)").arg(qstrNymWhoVerified);
                // -------------------------------
                QString qstrType("Output:");

                if (bSuccessVerifying)
                {
                    qstrType = QString("%1: %2").arg(tr("Verified signature by Nym")).arg(qstrNymWhoVerifiedName);
                }
                // -----------
                if (bSuccessDecrypting)
                {
                    if (bSuccessVerifying)
                        qstrType = QString("%1: %2\n%3: %4").arg(tr("Decrypted using Nym")).arg(qstrNymWhoDecryptedName).arg(tr("Verified signature by Nym")).arg(qstrNymWhoVerifiedName);
                    else
                        qstrType = QString("%1: %2").arg(tr("Decrypted using Nym")).arg(qstrNymWhoDecryptedName);
                }
                // -----------
                QString qstrSubTitle(tr("Be sure to copy it somewhere before closing this dialog."));
                // -----------
                // Pop up the result dialog.
                //
                DlgExportedToPass dlgExported(this, qstrText,
                                              qstrType,
                                              qstrSubTitle, false);
                dlgExported.exec();
            } // if (!qstrText.isEmpty())
        } // if strInput
    } //qstrText not empty
}
Пример #4
0
void DlgEncrypt::on_pushButtonEncrypt_clicked()
{
    QString qstrText = ui->plainTextEdit->toPlainText().trimmed();
    // --------------------------------
    if (qstrText.isEmpty())
    {
        // pop up a message box warning that the input text is empty.
        //
        QMessageBox::warning(this, tr("Input Text is Empty"),
                             tr("Please paste some text to be signed/encrypted."));
        return;
    }
    else
    {
        if (m_bSign)
        {
            if (m_nymId.isEmpty())
            {
                QMessageBox::warning(this, tr("Missing Signer"),
                                     tr("No signer is selected. Perhaps you need to create an identity first, to sign with."));
                return;
            }
            else
            {
                // Sign the contents.
                //
                std::string  str_nym    (m_nymId.toStdString());
                opentxs::String     strNym     (str_nym.c_str());
                opentxs::Identifier nym_id     (strNym);

                std::string  str_text   (qstrText.toStdString());
                opentxs::String     strText    (str_text.c_str());
//              opentxs::OTASCIIArmor ascText    (strText);
//              std::string  str_encoded(ascText.Get());
//              opentxs::String     strEncoded (str_encoded.c_str());
//              std::string  str_type   ("MESSAGE");

                if (!nym_id.IsEmpty())
                {
                    opentxs::OTPasswordData thePWData("Signer passphrase");

                    opentxs::Nym * pNym = opentxs::OTAPI_Wrap::OTAPI()->GetOrLoadPrivateNym(nym_id,
                                                                           false, //bChecking=false
                                                                           __FUNCTION__,
                                                                           &thePWData);
                    if (NULL == pNym)
                    {
                        QString qstrErrorMsg = QString("%1: %2").arg(tr("Failed loading the signer; unable to continue. NymID")).arg(m_nymId);
                        QMessageBox::warning(this, tr("Failed Loading Signer"), qstrErrorMsg);
                        return;
                    }
                    else
                    {
                        // FOR VERIFY STEP:
    //                  inline opentxs::String & opentxs::OTSignedFile::GetFilePayload()                       { return m_strSignedFilePayload;   }

                        opentxs::String     strSignedOutput;
                        opentxs::OTSignedFile theSignedFile;

                        theSignedFile.SetSignerNymID(strNym);

                        theSignedFile.SetFilePayload(strText);
                        theSignedFile.SignContract(*pNym, &thePWData);
                        theSignedFile.SaveContract();
                        theSignedFile.SaveContractRaw(strSignedOutput);

                        // Set the result onto qstrText
                        //
                        if (!strSignedOutput.Exists())
                        {
                            QMessageBox::warning(this, tr("Signing Failed"),
                                                 tr("Failed trying to sign, using the selected identity."));
                            return;
                        }
                        else if (!theSignedFile.VerifySignature(*pNym))
                        {
                            QMessageBox::warning(this, tr("Test Verification Failed"),
                                                 tr("Failed trying to test verify, immediately after signing. Trying authentication key..."));

                            if (!theSignedFile.VerifySigAuthent(*pNym))
                            {
                                QMessageBox::warning(this, tr("Authent Test Also Failed"),
                                                     tr("Failed trying to verify signature with authentication key as well."));
                                return;
                            }
                            else
                                QMessageBox::information(this, tr("SUCCESS USING AUTHENTICATION KEY"), tr("Tried authent key instead of signing key, and it worked!"));
                        }
                        else
                        {
                            std::string str_signed_output(strSignedOutput.Get());
                            qstrText = QString::fromStdString(str_signed_output);
                        }
                    } // else (we have pNym.)
                }
//              std::string  str_output (opentxs::OTAPI_Wrap::It()->FlatSign(str_nym, str_encoded, str_type));
            }
        }
        // --------------------------------
        // Encrypt qstrText and pop up a dialog with the encrypted result.
        //
        if (m_bEncrypt)
        {
            if (ui->listWidgetAdded->count() > 0)
            {
                std::set<const opentxs::Nym*> setRecipients;
                bool      bRecipientsShouldBeAvailable = false;

                // Loop through each NymID in listWidgetAdded, and put them on a opentxs::setOfNyms
                // so we can pass them along to opentxs::OTEnvelope (and so we can clean them up afterwards.)
                // UPDATE: Can't clean them up! Because the wallet only owns private nyms, not public
                // ones, we never know for sure which ones are safe to erase. TODO: Fix in OT by using
                // shared_ptr.
                //
                for (int nIndex = 0; nIndex < ui->listWidgetAdded->count(); ++nIndex)
                {
                    bRecipientsShouldBeAvailable = true;

                    QListWidgetItem   * pItem    = ui->listWidgetAdded->item(nIndex);
                    QVariant            qvarItem = pItem->data(Qt::UserRole);
                    QString             qstrNymID(qvarItem.toString());
                    std::string         str_nym(qstrNymID.toStdString());
                    opentxs::String     strNym(str_nym.c_str());
                    opentxs::Identifier nym_id(strNym);

                    if (!nym_id.IsEmpty())
                    {
                        opentxs::OTPasswordData thePWData("Sometimes need to load private part of nym in order to use its public key. (Fix that!)");

                        const opentxs::Nym * pNym = opentxs::OTAPI_Wrap::OTAPI()->GetOrLoadNym(nym_id,
                                                                               false, //bChecking=false
                                                                               __FUNCTION__,
                                                                               &thePWData);
                        if (NULL == pNym)
                        {
                            QString qstrErrorMsg = QString("%1: %2").arg(tr("Failed loading a recipient; attempting to continue without. NymID")).arg(qstrNymID);

                            QMessageBox::warning(this, tr("Failed Loading Recipient"), qstrErrorMsg);
                        }
                        else
                        {
                            setRecipients.insert(setRecipients.begin(), pNym);
                        }
                    }
                    // qstrNymID will be passed to opentxs::OTEnvelope on its recipient list.
                } // for (selected Nyms.)
                // ---------------------------------------------------
                // We might also want to encrypt to the Signer's Nym, if there is one.
                // We'll default this to ON, but give users the choice to deactivate it.
                //
                if (ui->checkBoxAlso->isVisible() &&
                    ui->checkBoxAlso->isEnabled() &&
                    ui->checkBoxAlso->isChecked() &&
                    !m_nymId.isEmpty())
                {
                    std::string str_signer_nym(m_nymId.toStdString());
                    opentxs::String strSignerNymID(str_signer_nym.c_str());
                    bool bSignerIsAlreadyThere = false;

                    //FOR_EACH(opentxs::setOfNyms(), setRecipients) // See if it's already there, in which case we don't need to do anything else.
                    for(auto it = setRecipients.begin(); it != setRecipients.end(); ++ it)
                    {
                        const opentxs::Nym       * pNym = *it;
                        opentxs::String            strNymID;
                        pNym->GetIdentifier(strNymID);

                        if (strSignerNymID.Compare(strNymID))
                            bSignerIsAlreadyThere = true;
                    }
                    // -------------------------
                    if (!bSignerIsAlreadyThere) // Not already there? Add signer to list of recipients.
                    {
                        bRecipientsShouldBeAvailable = true;

                        opentxs::Identifier signer_nym_id(strSignerNymID);

                        if (!signer_nym_id.IsEmpty())
                        {
                            opentxs::OTPasswordData thePWData("Sometimes need to load private part of nym in order to use its public key. (Fix that!)");

                            auto pNym =
                                opentxs::App::Me().Contract().Nym(signer_nym_id);
                            if (!pNym)
                            {
                                QString qstrErrorMsg = QString("%1: %2").
                                        arg(tr("Failed trying to load the signer; attempting to continue without. NymID")).arg(m_nymId);
                                QMessageBox::warning(this, tr("Failed Loading Signer"), qstrErrorMsg);
                            }
                            else
                            {
                                setRecipients.insert(setRecipients.begin(), pNym.get());
                            }
                        }
                    }
                }
                // ---------------------------------------------------
                if (setRecipients.size() > 0)
                {
                    opentxs::OTEnvelope theEnvelope;
                    opentxs::String   strInput(qstrText.toStdString().c_str());

                    if (!theEnvelope.Seal(setRecipients, strInput))
                    {
                        QMessageBox::warning(this, tr("Encryption Failed"),
                                             tr("Failed trying to encrypt message."));
                        return;
                    }
                    else
                    {
                        // Success encrypting!
                        //
                        opentxs::String     strOutput;
                        opentxs::OTASCIIArmor ascCiphertext(theEnvelope);

                        if (ascCiphertext.WriteArmoredString(strOutput, "ENVELOPE")) // -----BEGIN OT ARMORED ENVELOPE-----
                        {
                            std::string str_output(strOutput.Get());
                            qstrText = QString::fromStdString(str_output);
                        }
                    }
                }
                else if (bRecipientsShouldBeAvailable) // They should be, but they weren't.
                {
                    QMessageBox::warning(this, tr("Failed Loading Recipients"),
                                         tr("Due to failure loading any of the recipients, unable to commence."));
                    return;
                }
            } // if (listItems.size() > 0)
        } // if (m_bEncrypt)
        // -------------------
        // If it's NOT encrypted, but it IS signed, then we want to OT ARMOR it as well.
        // (We don't have to if it's encrypted, since that process already armors it for us.
        //  But this is for the case where it's signed and NOT encrypted.)
        //
        else if (m_bSign && !qstrText.isEmpty())
        {
            std::string  str_text(qstrText.toStdString());
            opentxs::String     strText (str_text.c_str());
            opentxs::String     strOutput;
            opentxs::OTASCIIArmor ascText (strText);

            if (ascText.WriteArmoredString(strOutput, "SIGNED FILE")) // -----BEGIN OT ARMORED SIGNED FILE-----
            {
                std::string str_output(strOutput.Get());
                qstrText = QString::fromStdString(str_output);
            }
        }
        // -----------------------------------------------
        // if qstrText still contains something, pop up a dialog to display the result to the user.
        //
        if (!qstrText.isEmpty())
        {
            QString qstrType("Output:");

            if (m_bSign)
            {
                qstrType = QString(tr("Signed Output:"));
            }
            // -----------
            if (m_bEncrypt)
            {
                if (m_bSign)
                    qstrType = QString(tr("Signed and Encrypted Output:"));
                else
                    qstrType = QString(tr("Encrypted Output:"));
            }
            // -----------
            QString qstrSubTitle(tr("Be sure to copy it somewhere before closing this dialog."));
            // -----------
            // Pop up the result dialog.
            //
            DlgExportedToPass dlgExported(this, qstrText,
                                          qstrType,
                                          qstrSubTitle, false);
            dlgExported.exec();
        }
    } // if (!qstrText.isEmpty())
}