int main(int argc, char **argv)
{
QCA::Initializer qcaInit;
QCoreApplication app(argc, argv);
if(argc < 3)
{
printf("usage: mozcerts [certdata.txt] [outfile.pem]\n");
return 0;
}
QFile infile(argv[1]);
if(!infile.open(QFile::ReadOnly))
{
fprintf(stderr, "Error opening input file\n");
return 1;
}
QFile outfile(argv[2]);
if(!outfile.open(QFile::WriteOnly | QFile::Truncate))
{
fprintf(stderr, "Error opening output file\n");
return 1;
}
int count = 0;
QString name;
QTextStream ts(&infile);
while(!ts.atEnd())
{
QString line = ts.readLine();
if(QRegExp("^#").indexIn(line) != -1)
continue;
if(QRegExp("^\\s*$").indexIn(line) != -1)
continue;
line = line.trimmed();
if(QRegExp("CKA_LABEL").indexIn(line) != -1)
{
QStringList list = splitWithQuotes(line, ' ');
if(list.count() != 3)
continue;
name = list[2];
// make an output filename based on the name
//outname = name.replace(QRegExp("\\/"), "_")
// .replace(QRegExp("\\s+"), "_")
// .replace(QRegExp("[()]"), "=")
// .replace(QRegExp(","), "_") + ".pem";
continue;
}
else if(QRegExp("CKA_VALUE MULTILINE_OCTAL").indexIn(line) != -1)
{
QByteArray buf;
while(!ts.atEnd())
{
line = ts.readLine();
if(QRegExp("^END").indexIn(line) != -1)
break;
line = line.trimmed();
QRegExp rx("\\\\([0-3][0-7][0-7])");
int pos = 0;
while((pos = rx.indexIn(line, pos)) != -1)
{
QString str = rx.capturedTexts()[1];
uchar c = str.toInt(0, 8);
buf.append(c);
pos += rx.matchedLength();
}
}
printf(">> [%s], %d bytes\n", qPrintable(name), buf.size());
QTextStream ts(&outfile);
ts << "-----BEGIN CERTIFICATE-----" << '\n';
QCA::Base64 enc;
enc.setLineBreaksEnabled(true);
enc.setLineBreaksColumn(64);
ts << enc.arrayToString(buf) << '\n';
ts << "-----END CERTIFICATE-----" << '\n';
++count;
}
}
printf("Wrote %d certs to [%s]\n", count, argv[2]);
return 0;
}
int main(int argc, char** argv)
{
// the Initializer object sets things up, and
// also does cleanup when it goes out of scope
QCA::Initializer init;
QCoreApplication app(argc, argv);
// We need to ensure that we have certificate handling support
if ( !QCA::isSupported( "cert" ) ) {
std::cout << "Sorry, no PKI certificate support" << std::endl;
return 1;
}
// Read in a private key
QCA::PrivateKey privKey;
QCA::ConvertResult convRes;
QCA::SecureArray passPhrase = "start";
privKey = QCA::PrivateKey::fromPEMFile( "Userkey.pem", passPhrase, &convRes );
if ( convRes != QCA::ConvertGood ) {
std::cout << "Sorry, could not import Private Key" << std::endl;
return 1;
}
// Read in a matching public key cert
// you could also build this using the fromPEMFile() method
QCA::Certificate pubCert( "User.pem" );
if ( pubCert.isNull() ) {
std::cout << "Sorry, could not import public key certificate" << std::endl;
return 1;
}
// We are building the certificate into a SecureMessageKey object, via a
// CertificateChain
QCA::SecureMessageKey secMsgKey;
QCA::CertificateChain chain;
chain += pubCert;
secMsgKey.setX509CertificateChain( chain );
// build up a SecureMessage object, based on our public key certificate
QCA::CMS cms;
QCA::SecureMessage msg(&cms);
msg.setRecipient(secMsgKey);
// Some plain text - we use the first command line argument if provided
QByteArray plainText = (argc >= 2) ? argv[1] : "What do ya want for nuthin'";
// Now use the SecureMessage object to encrypt the plain text.
msg.startEncrypt();
msg.update(plainText);
msg.end();
// I think it is reasonable to wait for 1 second for this
msg.waitForFinished(1000);
// check to see if it worked
if(!msg.success())
{
std::cout << "Error encrypting: " << msg.errorCode() << std::endl;
return 1;
}
// get the result
QCA::SecureArray cipherText = msg.read();
QCA::Base64 enc;
std::cout << plainText.data() << " encrypts to (in base 64): ";
std::cout << qPrintable( enc.arrayToString( cipherText ) ) << std::endl;
// Show we can decrypt it with the private key
if ( !privKey.canDecrypt() ) {
std::cout << "Private key cannot be used to decrypt" << std::endl;
return 1;
}
QCA::SecureArray plainTextResult;
if ( 0 == privKey.decrypt(cipherText, &plainTextResult, QCA::EME_PKCS1_OAEP ) ) {
std::cout << "Decryption process failed" << std::endl;
return 1;
}
std::cout << qPrintable( enc.arrayToString( cipherText ) );
std::cout << " (in base 64) decrypts to: ";
std::cout << plainTextResult.data() << std::endl;
return 0;
}