GckSession

GckSession — Represents an open PKCS11 session.

Synopsis

struct              GckSession;
enum                GckSessionOptions;
GckSession *          gck_session_from_handle           (GckSlot *slot,
                                                         CK_SESSION_HANDLE handle,
                                                         guint options);
GckModule *           gck_session_get_module            (GckSession *self);
GckSlot *             gck_session_get_slot              (GckSession *self);
CK_SESSION_HANDLE   gck_session_get_handle              (GckSession *self);
GckSessionInfo *      gck_session_get_info              (GckSession *self);
gboolean            gck_session_login                   (GckSession *self,
                                                         gulong user_type,
                                                         const guchar *pin,
                                                         gsize n_pin,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                gck_session_login_async             (GckSession *self,
                                                         gulong user_type,
                                                         const guchar *pin,
                                                         gsize n_pin,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            gck_session_login_finish            (GckSession *self,
                                                         GAsyncResult *result,
                                                         GError **error);
gboolean            gck_session_logout                  (GckSession *self,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                gck_session_logout_async            (GckSession *self,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            gck_session_logout_finish           (GckSession *self,
                                                         GAsyncResult *result,
                                                         GError **error);
GckObject *           gck_session_create_object         (GckSession *self,
                                                         GckAttributes *attrs,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                gck_session_create_object_async     (GckSession *self,
                                                         GckAttributes *attrs,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
GckObject *           gck_session_create_object_finish  (GckSession *self,
                                                         GAsyncResult *result,
                                                         GError **error);
GList *               gck_session_find_objects          (GckSession *self,
                                                         GckAttributes *attrs,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                gck_session_find_objects_async      (GckSession *self,
                                                         GckAttributes *attrs,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
GList *               gck_session_find_objects_finish   (GckSession *self,
                                                         GAsyncResult *result,
                                                         GError **error);
guchar *              gck_session_encrypt               (GckSession *self,
                                                         GckObject *key,
                                                         gulong mech_type,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **error);
guchar *              gck_session_encrypt_full          (GckSession *self,
                                                         GckObject *key,
                                                         GckMechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                gck_session_encrypt_async           (GckSession *self,
                                                         GckObject *key,
                                                         GckMechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
guchar *              gck_session_encrypt_finish        (GckSession *self,
                                                         GAsyncResult *result,
                                                         gsize *n_result,
                                                         GError **error);
guchar *              gck_session_decrypt               (GckSession *self,
                                                         GckObject *key,
                                                         gulong mech_type,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **error);
guchar *              gck_session_decrypt_full          (GckSession *self,
                                                         GckObject *key,
                                                         GckMechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                gck_session_decrypt_async           (GckSession *self,
                                                         GckObject *key,
                                                         GckMechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
guchar *              gck_session_decrypt_finish        (GckSession *self,
                                                         GAsyncResult *result,
                                                         gsize *n_result,
                                                         GError **error);
guchar *              gck_session_sign                  (GckSession *self,
                                                         GckObject *key,
                                                         gulong mech_type,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **error);
guchar *              gck_session_sign_full             (GckSession *self,
                                                         GckObject *key,
                                                         GckMechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                gck_session_sign_async              (GckSession *self,
                                                         GckObject *key,
                                                         GckMechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
guchar *              gck_session_sign_finish           (GckSession *self,
                                                         GAsyncResult *result,
                                                         gsize *n_result,
                                                         GError **error);
gboolean            gck_session_verify                  (GckSession *self,
                                                         GckObject *key,
                                                         gulong mech_type,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         const guchar *signature,
                                                         gsize n_signature,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            gck_session_verify_full             (GckSession *self,
                                                         GckObject *key,
                                                         GckMechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         const guchar *signature,
                                                         gsize n_signature,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                gck_session_verify_async            (GckSession *self,
                                                         GckObject *key,
                                                         GckMechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         const guchar *signature,
                                                         gsize n_signature,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            gck_session_verify_finish           (GckSession *self,
                                                         GAsyncResult *result,
                                                         GError **error);
GckObject *           gck_session_derive_key            (GckSession *self,
                                                         GckObject *base,
                                                         gulong mech_type,
                                                         GckAttributes *attrs,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                gck_session_derive_key_async        (GckSession *self,
                                                         GckObject *base,
                                                         GckMechanism *mechanism,
                                                         GckAttributes *attrs,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
GckObject *           gck_session_derive_key_finish     (GckSession *self,
                                                         GAsyncResult *result,
                                                         GError **error);
GckObject *           gck_session_derive_key_full       (GckSession *self,
                                                         GckObject *base,
                                                         GckMechanism *mechanism,
                                                         GckAttributes *attrs,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            gck_session_generate_key_pair       (GckSession *self,
                                                         gulong mech_type,
                                                         GckAttributes *public_attrs,
                                                         GckAttributes *private_attrs,
                                                         GckObject **public_key,
                                                         GckObject **private_key,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                gck_session_generate_key_pair_async (GckSession *self,
                                                         GckMechanism *mechanism,
                                                         GckAttributes *public_attrs,
                                                         GckAttributes *private_attrs,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            gck_session_generate_key_pair_finish
                                                        (GckSession *self,
                                                         GAsyncResult *result,
                                                         GckObject **public_key,
                                                         GckObject **private_key,
                                                         GError **error);
gboolean            gck_session_generate_key_pair_full  (GckSession *self,
                                                         GckMechanism *mechanism,
                                                         GckAttributes *public_attrs,
                                                         GckAttributes *private_attrs,
                                                         GckObject **public_key,
                                                         GckObject **private_key,
                                                         GCancellable *cancellable,
                                                         GError **error);
guint               gck_session_get_options             (GckSession *self);
gulong              gck_session_get_state               (GckSession *self);
GType               gck_session_get_type                (void);
gboolean            gck_session_init_pin                (GckSession *self,
                                                         const guchar *pin,
                                                         gsize n_pin,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                gck_session_init_pin_async          (GckSession *self,
                                                         const guchar *pin,
                                                         gsize n_pin,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            gck_session_init_pin_finish         (GckSession *self,
                                                         GAsyncResult *result,
                                                         GError **error);
gboolean            gck_session_set_pin                 (GckSession *self,
                                                         const guchar *old_pin,
                                                         gsize n_old_pin,
                                                         const guchar *new_pin,
                                                         gsize n_new_pin,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                gck_session_set_pin_async           (GckSession *self,
                                                         const guchar *old_pin,
                                                         gsize n_old_pin,
                                                         const guchar *new_pin,
                                                         gsize n_new_pin,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            gck_session_set_pin_finish          (GckSession *self,
                                                         GAsyncResult *result,
                                                         GError **error);
GckObject *           gck_session_unwrap_key            (GckSession *self,
                                                         GckObject *wrapper,
                                                         gulong mech_type,
                                                         gconstpointer input,
                                                         gsize n_input,
                                                         GckAttributes *attrs,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                gck_session_unwrap_key_async        (GckSession *self,
                                                         GckObject *wrapper,
                                                         GckMechanism *mechanism,
                                                         gconstpointer input,
                                                         gsize n_input,
                                                         GckAttributes *attrs,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
GckObject *           gck_session_unwrap_key_finish     (GckSession *self,
                                                         GAsyncResult *result,
                                                         GError **error);
GckObject *           gck_session_unwrap_key_full       (GckSession *self,
                                                         GckObject *wrapper,
                                                         GckMechanism *mechanism,
                                                         gconstpointer input,
                                                         gsize n_input,
                                                         GckAttributes *attrs,
                                                         GCancellable *cancellable,
                                                         GError **error);
gpointer            gck_session_wrap_key                (GckSession *self,
                                                         GckObject *wrapper,
                                                         gulong mech_type,
                                                         GckObject *wrapped,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                gck_session_wrap_key_async          (GckSession *self,
                                                         GckObject *wrapper,
                                                         GckMechanism *mechanism,
                                                         GckObject *wrapped,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gpointer            gck_session_wrap_key_finish         (GckSession *self,
                                                         GAsyncResult *result,
                                                         gsize *n_result,
                                                         GError **error);
gpointer            gck_session_wrap_key_full           (GckSession *self,
                                                         GckObject *wrapper,
                                                         GckMechanism *mechanism,
                                                         GckObject *wrapped,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **error);
                    GckSessionInfo;
void                gck_session_info_free               (GckSessionInfo *session_info);
                    GckMechanism;

Description

Before performing any PKCS11 operations, a session must be opened. This is analogous to an open database handle, or a file handle.

Details

struct GckSession

struct GckSession {
	GObject parent;
};

Represents an open PKCS11 session.

GObject parent;

derived from this.

enum GckSessionOptions

typedef enum _GckSessionOptions {
	GCK_SESSION_READ_WRITE = 1 << 1,
	GCK_SESSION_LOGIN_USER =  1 << 2,
	GCK_SESSION_AUTHENTICATE = 1 << 3,
} GckSessionOptions;

Options for creating sessions.

GCK_SESSION_READ_WRITE

Open sessions as read/write

GCK_SESSION_LOGIN_USER

Login as user on new sessions.

GCK_SESSION_AUTHENTICATE

Authenticate as necessary

gck_session_from_handle ()

GckSession *          gck_session_from_handle           (GckSlot *slot,
                                                         CK_SESSION_HANDLE handle,
                                                         guint options);

Initialize a GckSession object from a raw PKCS#11 session handle. Usually one would use the gck_slot_open_session() function to create a session.

slot :

The slot which the session belongs to.

handle :

The raw PKCS#11 handle of the session.

options :

Session options. Those which are used during opening a session have no effect.

Returns :

The new GckSession object.

gck_session_get_module ()

GckModule *           gck_session_get_module            (GckSession *self);

Get the PKCS#11 module to which this session belongs.

self :

The session object.

Returns :

The module, which should be unreffed after use.

gck_session_get_slot ()

GckSlot *             gck_session_get_slot              (GckSession *self);

Get the PKCS#11 slot to which this session belongs.

self :

The session object.

Returns :

The slot, which should be unreffed after use.

gck_session_get_handle ()

CK_SESSION_HANDLE   gck_session_get_handle              (GckSession *self);

Get the raw PKCS#11 session handle from a GckSession object.

self :

The session object.

Returns :

The raw session handle.

gck_session_get_info ()

GckSessionInfo *      gck_session_get_info              (GckSession *self);

Get information about the session.

self :

The session object.

Returns :

The session info. Use the gck_session_info_free() to release when done.

gck_session_login ()

gboolean            gck_session_login                   (GckSession *self,
                                                         gulong user_type,
                                                         const guchar *pin,
                                                         gsize n_pin,
                                                         GCancellable *cancellable,
                                                         GError **error);

Login the user on the session. This call may block for an indefinite period.

self :

Log in to this session.

user_type :

The type of login user.

pin :

The user's PIN, or NULL for protected authentication path.

n_pin :

The length of the PIN.

cancellable :

Optional cancellation object, or NULL.

error :

A location to return an error.

Returns :

Whether successful or not.

gck_session_login_async ()

void                gck_session_login_async             (GckSession *self,
                                                         gulong user_type,
                                                         const guchar *pin,
                                                         gsize n_pin,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Login the user on the session. This call will return immediately and completes asynchronously.

self :

Log in to this session.

user_type :

The type of login user.

pin :

The user's PIN, or NULL for protected authentication path.

n_pin :

The length of the PIN.

cancellable :

Optional cancellation object, or NULL.

callback :

Called when the operation completes.

user_data :

Data to pass to the callback.

gck_session_login_finish ()

gboolean            gck_session_login_finish            (GckSession *self,
                                                         GAsyncResult *result,
                                                         GError **error);

Get the result of a login operation.

self :

The session logged into.

result :

The result passed to the callback.

error :

A location to return an error.

Returns :

Whether the operation was successful or not.

gck_session_logout ()

gboolean            gck_session_logout                  (GckSession *self,
                                                         GCancellable *cancellable,
                                                         GError **error);

Log out of the session. This call may block for an indefinite period.

self :

Logout of this session.

cancellable :

Optional cancellation object, or NULL.

error :

A location to return an error.

Returns :

Whether the logout was successful or not.

gck_session_logout_async ()

void                gck_session_logout_async            (GckSession *self,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Log out of the session. This call returns immediately and completes asynchronously.

self :

Logout of this session.

cancellable :

Optional cancellation object, or NULL.

callback :

Called when the operation completes.

user_data :

Data to pass to the callback.

gck_session_logout_finish ()

gboolean            gck_session_logout_finish           (GckSession *self,
                                                         GAsyncResult *result,
                                                         GError **error);

Get the result of logging out of a session.

self :

Logout of this session.

result :

The result passed to the callback.

error :

A location to return an error.

Returns :

Whether the logout was successful or not.

gck_session_create_object ()

GckObject *           gck_session_create_object         (GckSession *self,
                                                         GckAttributes *attrs,
                                                         GCancellable *cancellable,
                                                         GError **error);

Create a new PKCS#11 object. This call may block for an indefinite period.

self :

The session to create the object on.

attrs :

The attributes to create the object with.

cancellable :

Optional cancellation object, or NULL.

error :

A location to return an error, or NULL.

Returns :

The newly created object or NULL if an error occurred.

gck_session_create_object_async ()

void                gck_session_create_object_async     (GckSession *self,
                                                         GckAttributes *attrs,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Create a new PKCS#11 object. This call will return immediately and complete asynchronously.

self :

The session to create the object on.

attrs :

The attributes to create the object with.

cancellable :

Optional cancellation object or NULL.

callback :

Called when the operation completes.

user_data :

Data to pass to the callback.

gck_session_create_object_finish ()

GckObject *           gck_session_create_object_finish  (GckSession *self,
                                                         GAsyncResult *result,
                                                         GError **error);

Get the result of creating a new PKCS#11 object.

self :

The session to create the object on.

result :

The result passed to the callback.

error :

A location to return an error, or NULL.

Returns :

The newly created object or NULL if an error occurred.

gck_session_find_objects ()

GList *               gck_session_find_objects          (GckSession *self,
                                                         GckAttributes *attrs,
                                                         GCancellable *cancellable,
                                                         GError **error);

Find the objects matching the passed attributes. This call may block for an indefinite period.

self :

The session to find objects on.

attrs :

The attributes to match.

cancellable :

Optional cancellation object or NULL.

error :

A location to return an error or NULL.

Returns :

A list of the matching objects, which may be empty.

gck_session_find_objects_async ()

void                gck_session_find_objects_async      (GckSession *self,
                                                         GckAttributes *attrs,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Find the objects matching the passed attributes. This call will return immediately and complete asynchronously.

self :

The session to find objects on.

attrs :

The attributes to match.

cancellable :

Optional cancellation object or NULL.

callback :

Called when the operation completes.

user_data :

Data to pass to the callback.

gck_session_find_objects_finish ()

GList *               gck_session_find_objects_finish   (GckSession *self,
                                                         GAsyncResult *result,
                                                         GError **error);

Get the result of a find operation.

self :

The session to find objects on.

result :

The attributes to match.

error :

A location to return an error.

Returns :

A list of the matching objects, which may be empty.

gck_session_encrypt ()

guchar *              gck_session_encrypt               (GckSession *self,
                                                         GckObject *key,
                                                         gulong mech_type,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **error);

Encrypt data in a mechanism specific manner. This call may block for an indefinite period.

self :

The session.

key :

The key to encrypt with.

mech_type :

The mechanism type to use for encryption.

input :

The data to encrypt.

n_input :

The length of the data to encrypt.

n_result :

A location to store the length of the result data.

cancellable :

Optional cancellation object, or NULL

error :

A location to place error information.

Returns :

The data that was encrypted, or NULL if an error occured.

gck_session_encrypt_full ()

guchar *              gck_session_encrypt_full          (GckSession *self,
                                                         GckObject *key,
                                                         GckMechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **error);

Encrypt data in a mechanism specific manner. This call may block for an indefinite period.

self :

The session.

key :

The key to encrypt with.

mechanism :

The mechanism type and parameters to use for encryption.

input :

The data to encrypt.

n_input :

The length of the data to encrypt.

n_result :

A location to store the length of the result data.

cancellable :

A GCancellable which can be used to cancel the operation.

error :

A location to place error information.

Returns :

The data that was encrypted, or NULL if an error occured.

gck_session_encrypt_async ()

void                gck_session_encrypt_async           (GckSession *self,
                                                         GckObject *key,
                                                         GckMechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Encrypt data in a mechanism specific manner. This call will return immediately and complete asynchronously.

self :

The session.

key :

The key to encrypt with.

mechanism :

The mechanism type and parameters to use for encryption.

input :

The data to encrypt.

n_input :

The length of the data to encrypt.

cancellable :

A GCancellable which can be used to cancel the operation.

callback :

Called when the operation completes.

user_data :

A pointer to pass to the callback.

gck_session_encrypt_finish ()

guchar *              gck_session_encrypt_finish        (GckSession *self,
                                                         GAsyncResult *result,
                                                         gsize *n_result,
                                                         GError **error);

Get the result of an encryption operation.

self :

The session.

result :

The result object passed to the callback.

n_result :

A location to store the length of the result data.

error :

A location to place error information.

Returns :

The data that was encrypted, or NULL if an error occurred.

gck_session_decrypt ()

guchar *              gck_session_decrypt               (GckSession *self,
                                                         GckObject *key,
                                                         gulong mech_type,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **error);

Decrypt data in a mechanism specific manner. This call may block for an indefinite period.

self :

The session.

key :

The key to decrypt with.

mech_type :

The mechanism type to use for decryption.

input :

The data to decrypt.

n_input :

The length of the data to decrypt.

n_result :

A location to store the length of the result data.

cancellable :

Optional cancellation object, or NULL

error :

A location to place an error.

Returns :

The data that was decrypted, or NULL if an error occured.

gck_session_decrypt_full ()

guchar *              gck_session_decrypt_full          (GckSession *self,
                                                         GckObject *key,
                                                         GckMechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **error);

Decrypt data in a mechanism specific manner. This call may block for an indefinite period.

self :

The session.

key :

The key to decrypt with.

mechanism :

The mechanism type and parameters to use for decryption.

input :

The data to decrypt.

n_input :

The length of the data to decrypt.

n_result :

A location to store the length of the result data.

cancellable :

A GCancellable which can be used to cancel the operation.

error :

A location to place error information.

Returns :

The data that was decrypted, or NULL if an error occured.

gck_session_decrypt_async ()

void                gck_session_decrypt_async           (GckSession *self,
                                                         GckObject *key,
                                                         GckMechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Decrypt data in a mechanism specific manner. This call will return immediately and complete asynchronously.

self :

The session.

key :

The key to decrypt with.

mechanism :

The mechanism type and parameters to use for decryption.

input :

The data to decrypt.

n_input :

The length of the data to decrypt.

cancellable :

A GCancellable which can be used to cancel the operation.

callback :

Called when the operation completes.

user_data :

A pointer to pass to the callback.

gck_session_decrypt_finish ()

guchar *              gck_session_decrypt_finish        (GckSession *self,
                                                         GAsyncResult *result,
                                                         gsize *n_result,
                                                         GError **error);

Get the result of an decryption operation.

self :

The session.

result :

The result object passed to the callback.

n_result :

A location to store the length of the result data.

error :

A location to place error information.

Returns :

The data that was decrypted, or NULL if an error occurred.

gck_session_sign ()

guchar *              gck_session_sign                  (GckSession *self,
                                                         GckObject *key,
                                                         gulong mech_type,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **error);

Sign data in a mechanism specific manner. This call may block for an indefinite period.

self :

The session.

key :

The key to sign with.

mech_type :

The mechanism type to use for signing.

input :

The data to sign.

n_input :

The length of the data to sign.

n_result :

A location to store the length of the result data.

cancellable :

Optional cancellation object, or NULL

error :

A location to place an error.

Returns :

The data that was signed, or NULL if an error occured.

gck_session_sign_full ()

guchar *              gck_session_sign_full             (GckSession *self,
                                                         GckObject *key,
                                                         GckMechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **error);

Sign data in a mechanism specific manner. This call may block for an indefinite period.

self :

The session.

key :

The key to sign with.

mechanism :

The mechanism type and parameters to use for signing.

input :

The data to sign.

n_input :

The length of the data to sign.

n_result :

A location to store the length of the result data.

cancellable :

A GCancellable which can be used to cancel the operation.

error :

A location to place error information.

Returns :

The data that was signed, or NULL if an error occured.

gck_session_sign_async ()

void                gck_session_sign_async              (GckSession *self,
                                                         GckObject *key,
                                                         GckMechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Sign data in a mechanism specific manner. This call will return immediately and complete asynchronously.

self :

The session.

key :

The key to sign with.

mechanism :

The mechanism type and parameters to use for signing.

input :

The data to sign.

n_input :

The length of the data to sign.

cancellable :

A GCancellable which can be used to cancel the operation.

callback :

Called when the operation completes.

user_data :

A pointer to pass to the callback.

gck_session_sign_finish ()

guchar *              gck_session_sign_finish           (GckSession *self,
                                                         GAsyncResult *result,
                                                         gsize *n_result,
                                                         GError **error);

Get the result of an signing operation.

self :

The session.

result :

The result object passed to the callback.

n_result :

A location to store the length of the result data.

error :

A location to place error information.

Returns :

The data that was signed, or NULL if an error occurred.

gck_session_verify ()

gboolean            gck_session_verify                  (GckSession *self,
                                                         GckObject *key,
                                                         gulong mech_type,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         const guchar *signature,
                                                         gsize n_signature,
                                                         GCancellable *cancellable,
                                                         GError **error);

Verify data in a mechanism specific manner. This call may block for an indefinite period.

self :

The session.

key :

The key to verify with.

mech_type :

The mechanism type to use for verifying.

input :

The data to verify.

n_input :

The length of the data to verify.

signature :

The signature.

n_signature :

The length of the signature.

cancellable :

Optional cancellation object, or NULL

error :

A location to place an error.

Returns :

TRUE if the data verified correctly, otherwise a failure or error occurred.

gck_session_verify_full ()

gboolean            gck_session_verify_full             (GckSession *self,
                                                         GckObject *key,
                                                         GckMechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         const guchar *signature,
                                                         gsize n_signature,
                                                         GCancellable *cancellable,
                                                         GError **error);

Verify data in a mechanism specific manner. This call may block for an indefinite period.

self :

The session.

key :

The key to verify with.

mechanism :

The mechanism type and parameters to use for signing.

input :

The data to verify.

n_input :

The length of the data to verify.

signature :

The signature.

n_signature :

The length of the signature.

cancellable :

A GCancellable which can be used to cancel the operation.

error :

A location to place an error.

Returns :

TRUE if the data verified correctly, otherwise a failure or error occurred.

gck_session_verify_async ()

void                gck_session_verify_async            (GckSession *self,
                                                         GckObject *key,
                                                         GckMechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         const guchar *signature,
                                                         gsize n_signature,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Verify data in a mechanism specific manner. This call returns immediately and completes asynchronously.

self :

The session.

key :

The key to verify with.

mechanism :

The mechanism type and parameters to use for signing.

input :

The data to verify.

n_input :

The length of the data to verify.

signature :

The signature.

n_signature :

The length of the signature.

cancellable :

A GCancellable which can be used to cancel the operation.

callback :

Called when the operation completes.

user_data :

A pointer to pass to the callback.

gck_session_verify_finish ()

gboolean            gck_session_verify_finish           (GckSession *self,
                                                         GAsyncResult *result,
                                                         GError **error);

Get the result of an verify operation.

self :

The session.

result :

The result object passed to the callback.

error :

A location to place error information.

Returns :

TRUE if the data verified correctly, otherwise a failure or error occurred.

gck_session_derive_key ()

GckObject *           gck_session_derive_key            (GckSession *self,
                                                         GckObject *base,
                                                         gulong mech_type,
                                                         GckAttributes *attrs,
                                                         GCancellable *cancellable,
                                                         GError **error);

Derive a key from another key. This call may block for an indefinite period.

self :

The session to use.

base :

The key to derive from.

mech_type :

The mechanism to use for derivation.

attrs :

Additional attributes for the derived key.

cancellable :

Optional cancellation object, or NULL.

error :

A location to return an error, or NULL.

Returns :

The new derived key or NULL if the operation failed.

gck_session_derive_key_async ()

void                gck_session_derive_key_async        (GckSession *self,
                                                         GckObject *base,
                                                         GckMechanism *mechanism,
                                                         GckAttributes *attrs,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Derive a key from another key. This call will return immediately and complete asynchronously.

self :

The session to use.

base :

The key to derive from.

mechanism :

The mechanism to use for derivation.

attrs :

Additional attributes for the derived key.

cancellable :

Optional cancellation object or NULL.

callback :

Called when the operation completes.

user_data :

Data to pass to the callback.

gck_session_derive_key_finish ()

GckObject *           gck_session_derive_key_finish     (GckSession *self,
                                                         GAsyncResult *result,
                                                         GError **error);

Get the result of a derive key operation.

self :

The session to use.

result :

The async result passed to the callback.

error :

A location to return an error.

Returns :

The new derived key or NULL if the operation failed.

gck_session_derive_key_full ()

GckObject *           gck_session_derive_key_full       (GckSession *self,
                                                         GckObject *base,
                                                         GckMechanism *mechanism,
                                                         GckAttributes *attrs,
                                                         GCancellable *cancellable,
                                                         GError **error);

Derive a key from another key. This call may block for an indefinite period.

self :

The session to use.

base :

The key to derive from.

mechanism :

The mechanism to use for derivation.

attrs :

Additional attributes for the derived key.

cancellable :

Optional cancellation object, or NULL.

error :

A location to return an error, or NULL.

Returns :

The new derived key or NULL if the operation failed.

gck_session_generate_key_pair ()

gboolean            gck_session_generate_key_pair       (GckSession *self,
                                                         gulong mech_type,
                                                         GckAttributes *public_attrs,
                                                         GckAttributes *private_attrs,
                                                         GckObject **public_key,
                                                         GckObject **private_key,
                                                         GCancellable *cancellable,
                                                         GError **error);

Generate a new key pair of public and private keys. This call may block for an indefinite period.

self :

The session to use.

mech_type :

The mechanism type to use for key generation.

public_attrs :

Additional attributes for the generated public key.

private_attrs :

Additional attributes for the generated private key.

public_key :

A location to return the resulting public key.

private_key :

A location to return the resulting private key.

cancellable :

Optional cancellation object, or NULL.

error :

A location to return an error, or NULL.

Returns :

TRUE if the operation succeeded.

gck_session_generate_key_pair_async ()

void                gck_session_generate_key_pair_async (GckSession *self,
                                                         GckMechanism *mechanism,
                                                         GckAttributes *public_attrs,
                                                         GckAttributes *private_attrs,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Generate a new key pair of public and private keys. This call will return immediately and complete asynchronously.

self :

The session to use.

mechanism :

The mechanism to use for key generation.

public_attrs :

Additional attributes for the generated public key.

private_attrs :

Additional attributes for the generated private key.

cancellable :

Optional cancellation object or NULL.

callback :

Called when the operation completes.

user_data :

Data to pass to the callback.

gck_session_generate_key_pair_finish ()

gboolean            gck_session_generate_key_pair_finish
                                                        (GckSession *self,
                                                         GAsyncResult *result,
                                                         GckObject **public_key,
                                                         GckObject **private_key,
                                                         GError **error);

Get the result of a generate key pair operation.

self :

The session to use.

result :

The async result passed to the callback.

public_key :

A location to return the resulting public key.

private_key :

A location to return the resulting private key.

error :

A location to return an error.

Returns :

TRUE if the operation succeeded.

gck_session_generate_key_pair_full ()

gboolean            gck_session_generate_key_pair_full  (GckSession *self,
                                                         GckMechanism *mechanism,
                                                         GckAttributes *public_attrs,
                                                         GckAttributes *private_attrs,
                                                         GckObject **public_key,
                                                         GckObject **private_key,
                                                         GCancellable *cancellable,
                                                         GError **error);

Generate a new key pair of public and private keys. This call may block for an indefinite period.

self :

The session to use.

mechanism :

The mechanism to use for key generation.

public_attrs :

Additional attributes for the generated public key.

private_attrs :

Additional attributes for the generated private key.

public_key :

A location to return the resulting public key.

private_key :

A location to return the resulting private key.

cancellable :

Optional cancellation object, or NULL.

error :

A location to return an error, or NULL.

Returns :

TRUE if the operation succeeded.

gck_session_get_options ()

guint               gck_session_get_options             (GckSession *self);

Get the options this session was opened with.

self :

The session to get options from.

Returns :

The session options.

gck_session_get_state ()

gulong              gck_session_get_state               (GckSession *self);


gck_session_get_type ()

GType               gck_session_get_type                (void);


gck_session_init_pin ()

gboolean            gck_session_init_pin                (GckSession *self,
                                                         const guchar *pin,
                                                         gsize n_pin,
                                                         GCancellable *cancellable,
                                                         GError **error);

Initialize the user's pin on this slot that this session is opened on. According to the PKCS#11 standards, the session must be logged in with the CKU_SO user type.

This call may block for an indefinite period.

self :

Initialize PIN for this session's slot.

pin :

The user's PIN, or NULL for protected authentication path.

n_pin :

The length of the PIN.

cancellable :

Optional cancellation object, or NULL.

error :

A location to return an error.

Returns :

Whether successful or not.

gck_session_init_pin_async ()

void                gck_session_init_pin_async          (GckSession *self,
                                                         const guchar *pin,
                                                         gsize n_pin,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Initialize the user's pin on this slot that this session is opened on. According to the PKCS#11 standards, the session must be logged in with the CKU_SO user type.

This call will return immediately and completes asynchronously.

self :

Initialize PIN for this session's slot.

pin :

The user's PIN, or NULL for protected authentication path.

n_pin :

The length of the PIN.

cancellable :

Optional cancellation object, or NULL.

callback :

Called when the operation completes.

user_data :

Data to pass to the callback.

gck_session_init_pin_finish ()

gboolean            gck_session_init_pin_finish         (GckSession *self,
                                                         GAsyncResult *result,
                                                         GError **error);

Get the result of initializing a user's PIN.

self :

The session.

result :

The result passed to the callback.

error :

A location to return an error.

Returns :

Whether the operation was successful or not.

gck_session_set_pin ()

gboolean            gck_session_set_pin                 (GckSession *self,
                                                         const guchar *old_pin,
                                                         gsize n_old_pin,
                                                         const guchar *new_pin,
                                                         gsize n_new_pin,
                                                         GCancellable *cancellable,
                                                         GError **error);

Change the user's pin on this slot that this session is opened on.

This call may block for an indefinite period.

self :

Change the PIN for this session's slot.

old_pin :

The user's old PIN, or NULL for protected authentication path.

n_old_pin :

The length of the PIN.

new_pin :

The user's new PIN, or NULL for protected authentication path.

n_new_pin :

The length of the PIN.

cancellable :

Optional cancellation object, or NULL.

error :

A location to return an error.

Returns :

Whether successful or not.

gck_session_set_pin_async ()

void                gck_session_set_pin_async           (GckSession *self,
                                                         const guchar *old_pin,
                                                         gsize n_old_pin,
                                                         const guchar *new_pin,
                                                         gsize n_new_pin,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Change the user's pin on this slot that this session is opened on.

This call will return immediately and completes asynchronously.

self :

Change the PIN for this session's slot.

old_pin :

The user's old PIN, or NULL for protected authentication path.

n_old_pin :

The length of the PIN.

new_pin :

The user's new PIN, or NULL for protected authentication path.

n_new_pin :

The length of the PIN.

cancellable :

Optional cancellation object, or NULL.

callback :

Called when the operation completes.

user_data :

Data to pass to the callback.

gck_session_set_pin_finish ()

gboolean            gck_session_set_pin_finish          (GckSession *self,
                                                         GAsyncResult *result,
                                                         GError **error);

Get the result of changing a user's PIN.

self :

The session.

result :

The result passed to the callback.

error :

A location to return an error.

Returns :

Whether the operation was successful or not.

gck_session_unwrap_key ()

GckObject *           gck_session_unwrap_key            (GckSession *self,
                                                         GckObject *wrapper,
                                                         gulong mech_type,
                                                         gconstpointer input,
                                                         gsize n_input,
                                                         GckAttributes *attrs,
                                                         GCancellable *cancellable,
                                                         GError **error);

Unwrap a key from a byte stream. This call may block for an indefinite period.

self :

The session to use.

wrapper :

The key to use for unwrapping.

mech_type :

The mechanism to use for unwrapping.

input :

The wrapped data as a byte stream.

n_input :

The length of the wrapped data.

attrs :

Additional attributes for the unwrapped key.

cancellable :

Optional cancellation object, or NULL.

error :

A location to return an error, or NULL.

Returns :

The new unwrapped key or NULL if the operation failed.

gck_session_unwrap_key_async ()

void                gck_session_unwrap_key_async        (GckSession *self,
                                                         GckObject *wrapper,
                                                         GckMechanism *mechanism,
                                                         gconstpointer input,
                                                         gsize n_input,
                                                         GckAttributes *attrs,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Unwrap a key from a byte stream. This call will return immediately and complete asynchronously.

self :

The session to use.

wrapper :

The key to use for unwrapping.

mechanism :

The mechanism to use for unwrapping.

input :

The wrapped data as a byte stream.

n_input :

The length of the wrapped data.

attrs :

Additional attributes for the unwrapped key.

cancellable :

Optional cancellation object or NULL.

callback :

Called when the operation completes.

user_data :

Data to pass to the callback.

gck_session_unwrap_key_finish ()

GckObject *           gck_session_unwrap_key_finish     (GckSession *self,
                                                         GAsyncResult *result,
                                                         GError **error);

Get the result of a unwrap key operation.

self :

The session to use.

result :

The async result passed to the callback.

error :

A location to return an error.

Returns :

The new unwrapped key or NULL if the operation failed.

gck_session_unwrap_key_full ()

GckObject *           gck_session_unwrap_key_full       (GckSession *self,
                                                         GckObject *wrapper,
                                                         GckMechanism *mechanism,
                                                         gconstpointer input,
                                                         gsize n_input,
                                                         GckAttributes *attrs,
                                                         GCancellable *cancellable,
                                                         GError **error);

Unwrap a key from a byte stream. This call may block for an indefinite period.

self :

The session to use.

wrapper :

The key to use for unwrapping.

mechanism :

The mechanism to use for unwrapping.

input :

The wrapped data as a byte stream.

n_input :

The length of the wrapped data.

attrs :

Additional attributes for the unwrapped key.

cancellable :

Optional cancellation object, or NULL.

error :

A location to return an error, or NULL.

Returns :

The new unwrapped key or NULL if the operation failed.

gck_session_wrap_key ()

gpointer            gck_session_wrap_key                (GckSession *self,
                                                         GckObject *wrapper,
                                                         gulong mech_type,
                                                         GckObject *wrapped,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **error);

Wrap a key into a byte stream. This call may block for an indefinite period.

self :

The session to use.

wrapper :

The key to use for wrapping.

mech_type :

The mechanism type to use for wrapping.

wrapped :

The key to wrap.

n_result :

A location in which to return the length of the wrapped data.

cancellable :

A GCancellable or NULL

error :

A location to return an error, or NULL.

Returns :

The wrapped data or NULL if the operation failed.

gck_session_wrap_key_async ()

void                gck_session_wrap_key_async          (GckSession *self,
                                                         GckObject *wrapper,
                                                         GckMechanism *mechanism,
                                                         GckObject *wrapped,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Wrap a key into a byte stream. This call will return immediately and complete asynchronously.

self :

The session to use.

wrapper :

The key to use for wrapping.

mechanism :

The mechanism to use for wrapping.

wrapped :

The key to wrap.

cancellable :

Optional cancellation object or NULL.

callback :

Called when the operation completes.

user_data :

Data to pass to the callback.

gck_session_wrap_key_finish ()

gpointer            gck_session_wrap_key_finish         (GckSession *self,
                                                         GAsyncResult *result,
                                                         gsize *n_result,
                                                         GError **error);

Get the result of a wrap key operation.

self :

The session to use.

result :

The async result passed to the callback.

n_result :

A location in which to return the length of the wrapped data.

error :

A location to return an error.

Returns :

The wrapped data or NULL if the operation failed.

gck_session_wrap_key_full ()

gpointer            gck_session_wrap_key_full           (GckSession *self,
                                                         GckObject *wrapper,
                                                         GckMechanism *mechanism,
                                                         GckObject *wrapped,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **error);

Wrap a key into a byte stream. This call may block for an indefinite period.

self :

The session to use.

wrapper :

The key to use for wrapping.

mechanism :

The mechanism to use for wrapping.

wrapped :

The key to wrap.

n_result :

A location in which to return the length of the wrapped data.

cancellable :

Optional cancellation object, or NULL.

error :

A location to return an error, or NULL.

Returns :

The wrapped data or NULL if the operation failed.

GckSessionInfo

typedef struct {
	gulong slot_id;
	gulong state;
	gulong flags;
	gulong device_error;
} GckSessionInfo;

Information about the session. This is analogous to a CK_SESSION_INFO structure.

When done with this structure, release it using gck_session_info_free().

gulong slot_id;

The handle of the PKCS11 slot that this session is opened on.

gulong state;

The user login state of the session.

gulong flags;

Various PKCS11 flags.

gulong device_error;

The last device error that occurred from an operation on this session.

gck_session_info_free ()

void                gck_session_info_free               (GckSessionInfo *session_info);

Free the GckSessionInfo structure and all associated memory.

session_info :

Session info to free.

GckMechanism

typedef struct {
	gulong type;
	gconstpointer parameter;
	gulong n_parameter;
} GckMechanism;

Represents a mechanism used with crypto operations.

gulong type;

The mechanism type

gconstpointer parameter;

Mechanism specific data.

gulong n_parameter;

Length of mechanism specific data.