QCA::PKey Class Reference
[QCA user API]

General superclass for public (PublicKey) and private (PrivateKey) keys used with asymmetric encryption techniques. More...

#include <QtCrypto>

Inheritance diagram for QCA::PKey:

QCA::Algorithm QCA::PrivateKey QCA::PublicKey QCA::DHPrivateKey QCA::DSAPrivateKey QCA::RSAPrivateKey QCA::DHPublicKey QCA::DSAPublicKey QCA::RSAPublicKey
Collaboration diagram for QCA::PKey:

Collaboration graph
[legend]

List of all members.

Public Types

enum  Type { RSA, DSA, DH }

Public Member Functions

int bitSize () const
bool canExport () const
bool canKeyAgree () const
bool isDH () const
bool isDSA () const
bool isNull () const
bool isPrivate () const
bool isPublic () const
bool isRSA () const
bool operator!= (const PKey &a) const
PKeyoperator= (const PKey &from)
bool operator== (const PKey &a) const
 PKey (const PKey &from)
 PKey ()
PrivateKey toPrivateKey () const
PublicKey toPublicKey () const
Type type () const

Static Public Member Functions

static QList< TypesupportedIOTypes (const QString &provider=QString())
static QList< TypesupportedTypes (const QString &provider=QString())

Protected Member Functions

 PKey (const QString &type, const QString &provider)
void set (const PKey &k)
DHPrivateKey toDHPrivateKey () const
DHPublicKey toDHPublicKey () const
DSAPrivateKey toDSAPrivateKey () const
DSAPublicKey toDSAPublicKey () const
RSAPrivateKey toRSAPrivateKey () const
RSAPublicKey toRSAPublicKey () const


Detailed Description

General superclass for public (PublicKey) and private (PrivateKey) keys used with asymmetric encryption techniques.

Member Enumeration Documentation

Types of public key cryptography keys supported by QCA.

Enumerator:
RSA  RSA key.
DSA  DSA key.
DH  Diffie Hellman key.


Constructor & Destructor Documentation

QCA::PKey::PKey (  ) 

Standard constructor.

QCA::PKey::PKey ( const PKey from  ) 

Standard copy constructor.

Parameters:
from the key to copy from

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

Create a key of the specified type.

Parameters:
type the name of the type of key to create
provider the name of the provider to create the key in


Member Function Documentation

int QCA::PKey::bitSize (  )  const

Report the number of bits in the key.

Examples:
keyloader.cpp.

bool QCA::PKey::canExport (  )  const

Test if the key data can be exported.

If the key resides on a smart card or other such device, this will likely return false.

bool QCA::PKey::canKeyAgree (  )  const

Test if the key can be used for key agreement.

bool QCA::PKey::isDH (  )  const

Test if the key is a Diffie Hellman key.

bool QCA::PKey::isDSA (  )  const

Test if the key is a DSA key.

bool QCA::PKey::isNull (  )  const

Test if the key is null (empty).

Returns:
true if the key is null
Examples:
rsatest.cpp.

bool QCA::PKey::isPrivate (  )  const

Test if the key is a private key.

bool QCA::PKey::isPublic (  )  const

Test if the key is a public key.

bool QCA::PKey::isRSA (  )  const

Test if the key is an RSA key.

bool QCA::PKey::operator!= ( const PKey a  )  const

test if two keys are not equal

Parameters:
a the key to compare with this key

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

Standard assignment operator.

Parameters:
from the PKey to copy from

bool QCA::PKey::operator== ( const PKey a  )  const

test if two keys are equal

Parameters:
a the key to compare with this key

void QCA::PKey::set ( const PKey k  )  [protected]

Set the key.

Parameters:
k the key to assign from

static QList<Type> QCA::PKey::supportedIOTypes ( const QString provider = QString()  )  [static]

Test what types of keys are supported for IO operations.

If you are using PKey DER or PEM operations, then you need to check for appropriate support using this method. For example, if you want to check if you can export or import an RSA key, then you need to do something like:

if(!QCA::isSupported("pkey") ||
        !QCA::PKey::supportedIOTypes().contains(QCA::PKey::RSA))
{
        // then there is no RSA key IO support
}
else
{
        // there is RSA key IO support
}

Note that if you only want to check for basic functionality (ie not PEM or DER import/export), then you can use supportedTypes(). There is no need to use both - if the key type is supported for IO, then is also supported for basic operations.

Parameters:
provider the name of the provider to use, if a particular provider is required.
See also:
supportedTypes()
Examples:
rsatest.cpp.

static QList<Type> QCA::PKey::supportedTypes ( const QString provider = QString()  )  [static]

Test what types of keys are supported.

Normally you would just test if the capability is present, however for PKey, you also need to test which types of keys are available. So if you want to figure out if RSA keys are supported, you need to do something like:

if(!QCA::isSupported("pkey") ||
        !QCA::PKey::supportedTypes().contains(QCA::PKey::RSA))
{
        // then there is no RSA key support
}
else
{
        // there is RSA key support
}

To make things a bit more complex, supportedTypes() only checks for basic functionality. If you want to check that you can do operations with PEM or DER (eg toPEM(), fromPEM(), and the equivalent DER and PEMfile operations, plus anything else that uses them, including the constructor form that takes a fileName), then you need to check for supportedIOTypes() instead.

Parameters:
provider the name of the provider to use, if a particular provider is required.
See also:
supportedIOTypes()

DHPrivateKey QCA::PKey::toDHPrivateKey (  )  const [protected]

Interpret this key as a DHPrivateKey.

Note:
This function is essentially a convenience cast - if the key was created as a DSA key, this function cannot turn it into a DH key.
See also:
toPrivateKey() for the public version of this method

DHPublicKey QCA::PKey::toDHPublicKey (  )  const [protected]

Interpret this key as an DHPublicKey.

Note:
This function is essentially a convenience cast - if the key was created as a DSA key, this function cannot turn it into a DH key.
See also:
toPublicKey() for the public version of this method

DSAPrivateKey QCA::PKey::toDSAPrivateKey (  )  const [protected]

Interpret this key as a DSAPrivateKey.

Note:
This function is essentially a convenience cast - if the key was created as an RSA key, this function cannot turn it into a DSA key.
See also:
toPrivateKey() for the public version of this method

DSAPublicKey QCA::PKey::toDSAPublicKey (  )  const [protected]

Interpret this key as an DSAPublicKey.

Note:
This function is essentially a convenience cast - if the key was created as an RSA key, this function cannot turn it into a DSA key.
See also:
toPublicKey() for the public version of this method

PrivateKey QCA::PKey::toPrivateKey (  )  const

Interpret this key as a PrivateKey.

PublicKey QCA::PKey::toPublicKey (  )  const

Interpret this key as a PublicKey.

See also:
toRSAPublicKey(), toDSAPublicKey() and toDHPublicKey() for protected forms of this call.
Examples:
rsatest.cpp.

RSAPrivateKey QCA::PKey::toRSAPrivateKey (  )  const [protected]

Interpret this key as an RSAPrivateKey.

Note:
This function is essentially a convenience cast - if the key was created as a DSA key, this function cannot turn it into a RSA key.
See also:
toPrivateKey() for the public version of this method

RSAPublicKey QCA::PKey::toRSAPublicKey (  )  const [protected]

Interpret this key as an RSAPublicKey.

Note:
This function is essentially a convenience cast - if the key was created as a DSA key, this function cannot turn it into an RSA key.
See also:
toPublicKey() for the public version of this method

Type QCA::PKey::type (  )  const

Report the Type of key (eg RSA, DSA or Diffie Hellman).

See also:
isRSA, isDSA and isDH for boolean tests.

Reimplemented from QCA::Algorithm.


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

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