QCA::PKey Class Reference
QCA user API

`#include <QtCrypto>`

Collaboration diagram for QCA::PKey:
[legend]

## 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
PKey & | operator= (const PKey &from)
bool | operator== (const PKey &a) const
| PKey ()
| PKey (const PKey &from)
PrivateKey | toPrivateKey () const
PublicKey | toPublicKey () const
Type | type () const
Public Member Functions inherited from QCA::Algorithm
| Algorithm (const Algorithm &from)
void | change (const QString &type, const QString &provider)
void | change (Provider::Context *c)
Provider::Context * | context ()
const Provider::Context * | context () const
Algorithm & | operator= (const Algorithm &from)
Provider * | provider () const
Provider::Context * | takeContext ()
QString | type () const

## Static Public Member Functions

static QList< Type > | supportedIOTypes (const QString &provider=QString())
static QList< Type > | supportedTypes (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
Protected Member Functions inherited from QCA::Algorithm
| Algorithm ()
| Algorithm (const QString &type, const QString &provider)

## Detailed Description

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

## Member Enumeration Documentation

## Type

enum QCA::PKey::Type

Types of public key cryptography keys supported by QCA.

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

## Constructor & Destructor Documentation

## PKey() [1/3]

QCA::PKey::PKey | ( |  | ) |

Standard constructor.

Referenced by operator!=(), operator=(), operator==(), PKey(), set(), and toDHPrivateKey().

## PKey() [2/3]

QCA::PKey::PKey | ( | const PKey & | from | ) |

Standard copy constructor.

Parameters

  from | the key to copy from

References PKey().

## PKey() [3/3]

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

References QCA::Algorithm::provider(), and type().

## Member Function Documentation

## operator=()

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

Standard assignment operator.

Parameters

  from | the PKey to copy from

References PKey().

## supportedTypes()

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
}
QCA::PKey::supportedTypes
static QList< Type > supportedTypes(const QString &provider=QString())
Test what types of keys are supported.
QCA::PKey::RSA
@ RSA
RSA key.
Definition qca_publickey.h:258
QCA::isSupported
QCA_EXPORT bool isSupported(const char *features, const QString &provider=QString())
Test if a capability (algorithm) is available.

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()

References QCA::Algorithm::provider().

## supportedIOTypes()

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
}
QCA::PKey::supportedIOTypes
static QList< Type > supportedIOTypes(const QString &provider=QString())
Test what types of keys are supported for IO operations.

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.

References QCA::Algorithm::provider().

## isNull()

bool QCA::PKey::isNull | ( |  | ) | const

Test if the key is null (empty).

Returns
  true if the key is null

Examples
  rsatest.cpp.

## type()

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.

Referenced by PKey(), QCA::PrivateKey::PrivateKey(), and QCA::PublicKey::PublicKey().

## bitSize()

int QCA::PKey::bitSize | ( |  | ) | const

Report the number of bits in the key.

Examples
  keyloader.cpp.

## isRSA()

bool QCA::PKey::isRSA | ( |  | ) | const

Test if the key is an RSA key.

## isDSA()

bool QCA::PKey::isDSA | ( |  | ) | const

Test if the key is a DSA key.

## isDH()

bool QCA::PKey::isDH | ( |  | ) | const

Test if the key is a Diffie Hellman key.

## isPublic()

bool QCA::PKey::isPublic | ( |  | ) | const

Test if the key is a public key.

## isPrivate()

bool QCA::PKey::isPrivate | ( |  | ) | const

Test if the key is a private key.

## canExport()

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.

## canKeyAgree()

bool QCA::PKey::canKeyAgree | ( |  | ) | const

Test if the key can be used for key agreement.

## toPublicKey()

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.

## toPrivateKey()

PrivateKey QCA::PKey::toPrivateKey | ( |  | ) | const

Interpret this key as a PrivateKey.

## operator==()

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

test if two keys are equal

Parameters

  a | the key to compare with this key

References PKey().

## operator!=()

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

test if two keys are not equal

Parameters

  a | the key to compare with this key

References PKey().

## set()

void QCA::PKey::set | ( | const PKey & | k | ) |

protected

Set the key.

Parameters

  k | the key to assign from

References PKey().

## toRSAPublicKey()

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

## toRSAPrivateKey()

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

## toDSAPublicKey()

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

## toDSAPrivateKey()

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

## toDHPublicKey()

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

## toDHPrivateKey()

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

References PKey().

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

- qca_publickey.h