QCA::PublicKey Class Reference
[QCA user API]

Generic public key. More...

#include <QtCrypto>

Inheritance diagram for QCA::PublicKey:

QCA::PKey QCA::Algorithm QCA::DHPublicKey QCA::DSAPublicKey QCA::RSAPublicKey
Collaboration diagram for QCA::PublicKey:

Collaboration graph
[legend]

List of all members.

Public Member Functions

bool canEncrypt () const
bool canVerify () const
SecureArray encrypt (const SecureArray &a, EncryptionAlgorithm alg)
int maximumEncryptSize (EncryptionAlgorithm alg) const
PublicKeyoperator= (const PublicKey &from)
 PublicKey (const PublicKey &from)
 PublicKey (const QString &fileName)
 PublicKey (const PrivateKey &k)
 PublicKey ()
void startVerify (SignatureAlgorithm alg, SignatureFormat format=DefaultFormat)
QByteArray toDER () const
DHPublicKey toDH () const
DSAPublicKey toDSA () const
QString toPEM () const
bool toPEMFile (const QString &fileName) const
RSAPublicKey toRSA () const
void update (const MemoryRegion &a)
bool validSignature (const QByteArray &sig)
bool verifyMessage (const MemoryRegion &a, const QByteArray &sig, SignatureAlgorithm alg, SignatureFormat format=DefaultFormat)

Static Public Member Functions

static PublicKey fromDER (const QByteArray &a, ConvertResult *result=0, const QString &provider=QString())
static PublicKey fromPEM (const QString &s, ConvertResult *result=0, const QString &provider=QString())
static PublicKey fromPEMFile (const QString &fileName, ConvertResult *result=0, const QString &provider=QString())

Protected Member Functions

 PublicKey (const QString &type, const QString &provider)


Detailed Description

Generic public key.
Examples:

rsatest.cpp.


Constructor & Destructor Documentation

QCA::PublicKey::PublicKey (  ) 

Create an empty (null) public key.

QCA::PublicKey::PublicKey ( const PrivateKey k  ) 

Create a public key based on a specified private key.

Parameters:
k the private key to extract the public key parts from

QCA::PublicKey::PublicKey ( const QString fileName  ) 

Import a public key from a PEM representation in a file.

Parameters:
fileName the name of the file containing the public key
See also:
fromPEMFile for an alternative method

QCA::PublicKey::PublicKey ( const PublicKey from  ) 

Copy constructor.

Parameters:
from the PublicKey to copy from

QCA::PublicKey::PublicKey ( const QString type,
const QString provider 
) [protected]

Create a new key of a specified type.

Parameters:
type the type of key to create
provider the provider to use, if required


Member Function Documentation

bool QCA::PublicKey::canEncrypt (  )  const

Test if this key can be used for encryption.

Returns:
true if the key can be used for encryption
Examples:
rsatest.cpp.

bool QCA::PublicKey::canVerify (  )  const

Test if the key can be used for verifying signatures.

Returns:
true of the key can be used for verification
Examples:
rsatest.cpp.

SecureArray QCA::PublicKey::encrypt ( const SecureArray a,
EncryptionAlgorithm  alg 
)

Encrypt a message using a specified algorithm.

Parameters:
a the message to encrypt
alg the algorithm to use
Examples:
rsatest.cpp.

static PublicKey QCA::PublicKey::fromDER ( const QByteArray a,
ConvertResult result = 0,
const QString provider = QString() 
) [static]

Import a key in Distinguished Encoding Rules (DER) format.

This function takes a binary array, which is assumed to contain a public key in DER encoding, and returns the key. Unless you don't care whether the import succeeded, you should test the result, as shown below.

QCA::ConvertResult conversionResult;
QCA::PublicKey publicKey = QCA::PublicKey::fromDER(keyArray, &conversionResult);
if (! QCA::ConvertGood == conversionResult)
{
        std::cout << "Public key read failed" << std::endl;
}

Parameters:
a the array containing a DER encoded key
result pointer to a variable, which returns whether the conversion succeeded (ConvertGood) or not
provider the name of the provider to use for the import.

static PublicKey QCA::PublicKey::fromPEM ( const QString s,
ConvertResult result = 0,
const QString provider = QString() 
) [static]

Import a key in Privacy Enhanced Mail (PEM) format.

This function takes a string, which is assumed to contain a public key in PEM encoding, and returns that key. Unless you don't care whether the import succeeded, you should test the result, as shown below.

QCA::ConvertResult conversionResult;
QCA::PublicKey publicKey = QCA::PublicKey::fromPEM(keyAsString, &conversionResult);
if (! QCA::ConvertGood == conversionResult)
{
        std::cout << "Public key read failed" << std::endl;
}

Parameters:
s the string containing a PEM encoded key
result pointer to a variable, which returns whether the conversion succeeded (ConvertGood) or not
provider the name of the provider to use for the import.
See also:
toPEM, which provides an inverse of fromPEM()

fromPEMFile, which provides an import direct from a file.

static PublicKey QCA::PublicKey::fromPEMFile ( const QString fileName,
ConvertResult result = 0,
const QString provider = QString() 
) [static]

Import a key in Privacy Enhanced Mail (PEM) format from a file.

This function takes the name of a file, which is assumed to contain a public key in PEM encoding, and returns that key. Unless you don't care whether the import succeeded, you should test the result, as shown below.

QCA::ConvertResult conversionResult;
QCA::PublicKey publicKey = QCA::PublicKey::fromPEMFile(fileName, &conversionResult);
if (! QCA::ConvertGood == conversionResult)
{
        std::cout << "Public key read failed" << std::endl;
}

Parameters:
fileName a string containing the name of the file
result pointer to a variable, which returns whether the conversion succeeded (ConvertGood) or not
provider the name of the provider to use for the import.
See also:
toPEMFile, which provides an inverse of fromPEMFile()

fromPEM, which provides an import from a string

Note:
there is also a constructor form that can import from a file

int QCA::PublicKey::maximumEncryptSize ( EncryptionAlgorithm  alg  )  const

The maximum message size that can be encrypted with a specified algorithm.

Parameters:
alg the algorithm to check

PublicKey& QCA::PublicKey::operator= ( const PublicKey from  ) 

Assignment operator.

Parameters:
from the PublicKey to copy from

void QCA::PublicKey::startVerify ( SignatureAlgorithm  alg,
SignatureFormat  format = DefaultFormat 
)

Initialise the signature verification process.

Parameters:
alg the algorithm to use for signing
format the specific format to use, for DSA
Examples:
rsatest.cpp.

QByteArray QCA::PublicKey::toDER (  )  const

Export the key in Distinguished Encoding Rules (DER) format.

DHPublicKey QCA::PublicKey::toDH (  )  const

Convenience method to convert this key to a DHPublicKey.

Note that if the key is not an DH key (eg it is DSA or RSA), then this will produce a null key.

DSAPublicKey QCA::PublicKey::toDSA (  )  const

Convenience method to convert this key to a DSAPublicKey.

Note that if the key is not an DSA key (eg it is RSA or DH), then this will produce a null key.

QString QCA::PublicKey::toPEM (  )  const

Export the key in Privacy Enhanced Mail (PEM) format.

See also:
toPEMFile provides a convenient way to save the PEM encoded key to a file

fromPEM provides an inverse of toPEM, converting the PEM encoded key back to a PublicKey

bool QCA::PublicKey::toPEMFile ( const QString fileName  )  const

Export the key in Privacy Enhanced Mail (PEM) to a file.

Parameters:
fileName the name (and path, if necessary) of the file to save the PEM encoded key to.
See also:
toPEM for a version that exports to a QString, which may be useful if you need to do more sophisticated handling

fromPEMFile provides an inverse of toPEMFile, reading a PEM encoded key from a file

RSAPublicKey QCA::PublicKey::toRSA (  )  const

Convenience method to convert this key to an RSAPublicKey.

Note that if the key is not an RSA key (eg it is DSA or DH), then this will produce a null key.

void QCA::PublicKey::update ( const MemoryRegion a  ) 

Update the signature verification process with more data.

Parameters:
a the array containing the data that should be added to the signature
Examples:
rsatest.cpp.

bool QCA::PublicKey::validSignature ( const QByteArray sig  ) 

Check the signature is valid for the message.

The process to check that a signature is correct is shown below:

// note that pubkey is a PublicKey
if( pubkey.canVerify() )
{
        pubkey.startVerify( QCA::EMSA3_MD5 );
        pubkey.update( theMessage ); // might be called multiple times
        if ( pubkey.validSignature( theSignature ) )
        {
                // then signature is valid
        }
        else
        {
                // then signature is invalid
        }
}

Parameters:
sig the signature to check
Returns:
true if the signature is correct
Examples:
rsatest.cpp.

bool QCA::PublicKey::verifyMessage ( const MemoryRegion a,
const QByteArray sig,
SignatureAlgorithm  alg,
SignatureFormat  format = DefaultFormat 
)

Single step message verification.

If you have the whole message to be verified, then this offers a more convenient approach to verification.

Parameters:
a the message to check the signature on
sig the signature to be checked
alg the algorithm to use
format the signature format to use, for DSA
Returns:
true if the signature is valid for the message
Examples:
rsatest.cpp.


The documentation for this class was generated from the following file:

Generated on Wed Apr 29 15:16:08 2009 for Qt Cryptographic Architecture by  doxygen 1.5.5