Struct pkcs11::Ctx

pub struct Ctx { /* fields omitted */ }

Methods

impl Ctx

pub fn new<P>(filename: P) -> Result<Ctx, Error> where
    P: AsRef<Path>, 

pub fn new_and_initialize<P>(filename: P) -> Result<Ctx, Error> where
    P: AsRef<Path>, 

pub fn is_initialized(&self) -> bool

pub fn initialize(
    &mut self,
    init_args: Option<CK_C_INITIALIZE_ARGS>
) -> Result<(), Error>

pub fn finalize(&mut self) -> Result<(), Error>

pub fn get_info(&self) -> Result<CK_INFO, Error>

pub fn get_function_list(&self) -> Result<CK_FUNCTION_LIST, Error>

pub fn get_slot_list(
    &self,
    token_present: bool
) -> Result<Vec<CK_SLOT_ID>, Error>

pub fn get_slot_info(&self, slot_id: CK_SLOT_ID) -> Result<CK_SLOT_INFO, Error>

pub fn get_token_info(
    &self,
    slot_id: CK_SLOT_ID
) -> Result<CK_TOKEN_INFO, Error>

pub fn get_mechanism_list(
    &self,
    slot_id: CK_SLOT_ID
) -> Result<Vec<CK_MECHANISM_TYPE>, Error>

pub fn get_mechanism_info(
    &self,
    slot_id: CK_SLOT_ID,
    mechanism_type: CK_MECHANISM_TYPE
) -> Result<CK_MECHANISM_INFO, Error>

pub fn init_token<'a, 'b>(
    &self,
    slot_id: CK_SLOT_ID,
    pin: Option<&'a str>,
    label: &'b str
) -> Result<(), Error>

pub fn init_pin<'a>(
    &self,
    session: CK_SESSION_HANDLE,
    pin: Option<&'a str>
) -> Result<(), Error>

pub fn set_pin<'a, 'b>(
    &self,
    session: CK_SESSION_HANDLE,
    old_pin: Option<&'a str>,
    new_pin: Option<&'b str>
) -> Result<(), Error>

pub fn open_session(
    &self,
    slot_id: CK_SLOT_ID,
    flags: CK_FLAGS,
    application: Option<CK_VOID_PTR>,
    notify: CK_NOTIFY
) -> Result<CK_SESSION_HANDLE, Error>

pub fn close_session(&self, session: CK_SESSION_HANDLE) -> Result<(), Error>

pub fn close_all_sessions(&self, slot_id: CK_SLOT_ID) -> Result<(), Error>

pub fn get_session_info(
    &self,
    session: CK_SESSION_HANDLE
) -> Result<CK_SESSION_INFO, Error>

pub fn get_operation_state(
    &self,
    session: CK_SESSION_HANDLE
) -> Result<Vec<CK_BYTE>, Error>

pub fn set_operation_state(
    &self,
    session: CK_SESSION_HANDLE,
    operation_state: Vec<CK_BYTE>,
    encryption_key: Option<CK_OBJECT_HANDLE>,
    authentication_key: Option<CK_OBJECT_HANDLE>
) -> Result<(), Error>

pub fn login<'a>(
    &self,
    session: CK_SESSION_HANDLE,
    user_type: CK_USER_TYPE,
    pin: Option<&'a str>
) -> Result<(), Error>

pub fn login_with_raw<'a>(
    &self,
    session: CK_SESSION_HANDLE,
    user_type: CK_USER_TYPE,
    pin: Option<&Vec<CK_BYTE>>
) -> Result<(), Error>

pub fn logout(&self, session: CK_SESSION_HANDLE) -> Result<(), Error>

pub fn create_object(
    &self,
    session: CK_SESSION_HANDLE,
    template: &Vec<CK_ATTRIBUTE>
) -> Result<CK_OBJECT_HANDLE, Error>

pub fn copy_object(
    &self,
    session: CK_SESSION_HANDLE,
    object: CK_OBJECT_HANDLE,
    template: &Vec<CK_ATTRIBUTE>
) -> Result<CK_OBJECT_HANDLE, Error>

pub fn destroy_object(
    &self,
    session: CK_SESSION_HANDLE,
    object: CK_OBJECT_HANDLE
) -> Result<(), Error>

pub fn get_object_size(
    &self,
    session: CK_SESSION_HANDLE,
    object: CK_OBJECT_HANDLE
) -> Result<CK_ULONG, Error>

pub fn get_attribute_value<'a>(
    &self,
    session: CK_SESSION_HANDLE,
    object: CK_OBJECT_HANDLE,
    template: &'a mut Vec<CK_ATTRIBUTE>
) -> Result<(CK_RV, &'a Vec<CK_ATTRIBUTE>), Error>

pub fn set_attribute_value(
    &self,
    session: CK_SESSION_HANDLE,
    object: CK_OBJECT_HANDLE,
    template: &Vec<CK_ATTRIBUTE>
) -> Result<(), Error>

pub fn find_objects_init(
    &self,
    session: CK_SESSION_HANDLE,
    template: &Vec<CK_ATTRIBUTE>
) -> Result<(), Error>

pub fn find_objects(
    &self,
    session: CK_SESSION_HANDLE,
    max_object_count: CK_ULONG
) -> Result<Vec<CK_OBJECT_HANDLE>, Error>

pub fn find_objects_final(
    &self,
    session: CK_SESSION_HANDLE
) -> Result<(), Error>

pub fn encrypt_init(
    &self,
    session: CK_SESSION_HANDLE,
    mechanism: &CK_MECHANISM,
    key: CK_OBJECT_HANDLE
) -> Result<(), Error>

pub fn encrypt(
    &self,
    session: CK_SESSION_HANDLE,
    data: &Vec<CK_BYTE>
) -> Result<Vec<CK_BYTE>, Error>

pub fn encrypt_update(
    &self,
    session: CK_SESSION_HANDLE,
    part: &Vec<CK_BYTE>
) -> Result<Vec<CK_BYTE>, Error>

pub fn encrypt_final(
    &self,
    session: CK_SESSION_HANDLE
) -> Result<Option<Vec<CK_BYTE>>, Error>

pub fn decrypt_init(
    &self,
    session: CK_SESSION_HANDLE,
    mechanism: &CK_MECHANISM,
    key: CK_OBJECT_HANDLE
) -> Result<(), Error>

pub fn decrypt(
    &self,
    session: CK_SESSION_HANDLE,
    encryptedData: &Vec<CK_BYTE>
) -> Result<Vec<CK_BYTE>, Error>

pub fn decrypt_update(
    &self,
    session: CK_SESSION_HANDLE,
    encryptedPart: &Vec<CK_BYTE>
) -> Result<Vec<CK_BYTE>, Error>

pub fn decrypt_final(
    &self,
    session: CK_SESSION_HANDLE
) -> Result<Option<Vec<CK_BYTE>>, Error>

pub fn digest_init(
    &self,
    session: CK_SESSION_HANDLE,
    mechanism: &CK_MECHANISM
) -> Result<(), Error>

pub fn digest(
    &self,
    session: CK_SESSION_HANDLE,
    data: &Vec<CK_BYTE>
) -> Result<Vec<CK_BYTE>, Error>

pub fn digest_update(
    &self,
    session: CK_SESSION_HANDLE,
    part: &Vec<CK_BYTE>
) -> Result<(), Error>

pub fn digest_key(
    &self,
    session: CK_SESSION_HANDLE,
    key: CK_OBJECT_HANDLE
) -> Result<(), Error>

pub fn digest_final(
    &self,
    session: CK_SESSION_HANDLE
) -> Result<Vec<CK_BYTE>, Error>

pub fn sign_init(
    &self,
    session: CK_SESSION_HANDLE,
    mechanism: &CK_MECHANISM,
    key: CK_OBJECT_HANDLE
) -> Result<(), Error>

pub fn sign(
    &self,
    session: CK_SESSION_HANDLE,
    data: &Vec<CK_BYTE>
) -> Result<Vec<CK_BYTE>, Error>

pub fn sign_update(
    &self,
    session: CK_SESSION_HANDLE,
    part: &Vec<CK_BYTE>
) -> Result<(), Error>

pub fn sign_final(
    &self,
    session: CK_SESSION_HANDLE
) -> Result<Vec<CK_BYTE>, Error>

pub fn sign_recover_init(
    &self,
    session: CK_SESSION_HANDLE,
    mechanism: &CK_MECHANISM,
    key: CK_OBJECT_HANDLE
) -> Result<(), Error>

pub fn sign_recover(
    &self,
    session: CK_SESSION_HANDLE,
    data: &Vec<CK_BYTE>
) -> Result<Vec<CK_BYTE>, Error>

pub fn verify_init(
    &self,
    session: CK_SESSION_HANDLE,
    mechanism: &CK_MECHANISM,
    key: CK_OBJECT_HANDLE
) -> Result<(), Error>

pub fn verify(
    &self,
    session: CK_SESSION_HANDLE,
    data: &Vec<CK_BYTE>,
    signature: &Vec<CK_BYTE>
) -> Result<(), Error>

pub fn verify_update(
    &self,
    session: CK_SESSION_HANDLE,
    part: &Vec<CK_BYTE>
) -> Result<(), Error>

pub fn verify_final(
    &self,
    session: CK_SESSION_HANDLE,
    signature: &Vec<CK_BYTE>
) -> Result<(), Error>

pub fn verify_recover_init(
    &self,
    session: CK_SESSION_HANDLE,
    mechanism: &CK_MECHANISM,
    key: CK_OBJECT_HANDLE
) -> Result<(), Error>

pub fn verify_recover(
    &self,
    session: CK_SESSION_HANDLE,
    signature: &Vec<CK_BYTE>
) -> Result<Vec<CK_BYTE>, Error>

pub fn digest_encrypt_update(
    &self,
    session: CK_SESSION_HANDLE,
    part: &Vec<CK_BYTE>
) -> Result<Vec<CK_BYTE>, Error>

pub fn decrypt_digest_update(
    &self,
    session: CK_SESSION_HANDLE,
    encryptedPart: &Vec<CK_BYTE>
) -> Result<Vec<CK_BYTE>, Error>

pub fn sign_encrypt_update(
    &self,
    session: CK_SESSION_HANDLE,
    part: &Vec<CK_BYTE>
) -> Result<Vec<CK_BYTE>, Error>

pub fn decrypt_verify_update(
    &self,
    session: CK_SESSION_HANDLE,
    encryptedPart: Vec<CK_BYTE>
) -> Result<Vec<CK_BYTE>, Error>

pub fn generate_key(
    &self,
    session: CK_SESSION_HANDLE,
    mechanism: &CK_MECHANISM,
    template: &Vec<CK_ATTRIBUTE>
) -> Result<CK_OBJECT_HANDLE, Error>

pub fn generate_key_pair(
    &self,
    session: CK_SESSION_HANDLE,
    mechanism: &CK_MECHANISM,
    publicKeyTemplate: &Vec<CK_ATTRIBUTE>,
    privateKeyTemplate: &Vec<CK_ATTRIBUTE>
) -> Result<(CK_OBJECT_HANDLE, CK_OBJECT_HANDLE), Error>

pub fn wrap_key(
    &self,
    session: CK_SESSION_HANDLE,
    mechanism: &CK_MECHANISM,
    wrappingKey: CK_OBJECT_HANDLE,
    key: CK_OBJECT_HANDLE
) -> Result<Vec<CK_BYTE>, Error>

pub fn unwrap_key(
    &self,
    session: CK_SESSION_HANDLE,
    mechanism: &CK_MECHANISM,
    unwrappingKey: CK_OBJECT_HANDLE,
    wrappedKey: &Vec<CK_BYTE>,
    template: &Vec<CK_ATTRIBUTE>
) -> Result<CK_OBJECT_HANDLE, Error>

pub fn derive_key(
    &self,
    session: CK_SESSION_HANDLE,
    mechanism: &CK_MECHANISM,
    baseKey: CK_OBJECT_HANDLE,
    template: &Vec<CK_ATTRIBUTE>
) -> Result<CK_OBJECT_HANDLE, Error>

pub fn seed_random(
    &self,
    session: CK_SESSION_HANDLE,
    seed: &Vec<CK_BYTE>
) -> Result<(), Error>

pub fn generate_random(
    &self,
    session: CK_SESSION_HANDLE,
    randomLength: CK_ULONG
) -> Result<Vec<CK_BYTE>, Error>

pub fn get_function_status(
    &self,
    session: CK_SESSION_HANDLE
) -> Result<CK_RV, Error>

pub fn cancel_function(
    &self,
    session: CK_SESSION_HANDLE
) -> Result<CK_RV, Error>

pub fn wait_for_slot_event(&self, flags: CK_FLAGS) -> Result<CK_SLOT_ID, Error>

Trait Implementations

impl Drop for Ctx

fn drop(&mut self)

Executes the destructor for this type.

impl Debug for Ctx

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.