OPENCDK_VERSION

#define OPENCDK_VERSION "0.5.11"

struct cdk_ctx_s

struct cdk_ctx_s;

cdk_ctx_t

typedef struct cdk_ctx_s *cdk_ctx_t;

struct cdk_strlist_s

struct cdk_strlist_s;

cdk_strlist_t

typedef struct cdk_strlist_s *cdk_strlist_t;

struct cdk_sesskey_s

struct cdk_sesskey_s;

cdk_sesskey_t

typedef struct cdk_sesskey_s *cdk_sesskey_t;

struct cdk_listkey_s

struct cdk_listkey_s;

cdk_listkey_t

typedef struct cdk_listkey_s *cdk_listkey_t;

struct cdk_mpi_s

struct cdk_mpi_s;

cdk_mpi_t

typedef struct cdk_mpi_s *cdk_mpi_t;

struct cdk_dek_s

struct cdk_dek_s;

cdk_dek_t

typedef struct cdk_dek_s *cdk_dek_t;

struct cdk_s2k_s

struct cdk_s2k_s;

cdk_s2k_t

typedef struct cdk_s2k_s *cdk_s2k_t;

struct cdk_stream_s

struct cdk_stream_s;

cdk_stream_t

typedef struct cdk_stream_s *cdk_stream_t;

struct cdk_prefitem_s

struct cdk_prefitem_s;

cdk_prefitem_t

typedef struct cdk_prefitem_s *cdk_prefitem_t;

struct cdk_kbnode_s

struct cdk_kbnode_s;

cdk_kbnode_t

typedef struct cdk_kbnode_s *cdk_kbnode_t;

struct cdk_keydb_hd_s

struct cdk_keydb_hd_s;

cdk_keydb_hd_t

typedef struct cdk_keydb_hd_s *cdk_keydb_hd_t;

struct cdk_keylist_s

struct cdk_keylist_s;

cdk_keylist_t

typedef struct cdk_keylist_s *cdk_keylist_t;

struct cdk_subpkt_s

struct cdk_subpkt_s;

cdk_subpkt_t

typedef struct cdk_subpkt_s *cdk_subpkt_t;

struct cdk_keygen_ctx_s

struct cdk_keygen_ctx_s;

cdk_keygen_ctx_t

typedef struct cdk_keygen_ctx_s *cdk_keygen_ctx_t;

struct cdk_desig_revoker_s

struct cdk_desig_revoker_s;

cdk_desig_revoker_t

typedef struct cdk_desig_revoker_s *cdk_desig_revoker_t;

struct cdk_md_hd_s

struct cdk_md_hd_s;

cdk_md_hd_t

typedef struct cdk_md_hd_s *cdk_md_hd_t;

struct cdk_cipher_hd_s

struct cdk_cipher_hd_s;

cdk_cipher_hd_t

typedef struct cdk_cipher_hd_s *cdk_cipher_hd_t;

enum cdk_error_t

typedef enum {
    CDK_EOF = -1,
    CDK_Success = 0,
    CDK_General_Error = 1,
    CDK_File_Error = 2,
    CDK_Bad_Sig = 3,
    CDK_Inv_Packet = 4,
    CDK_Inv_Algo = 5,
    CDK_Not_Implemented = 6,
    CDK_Gcry_Error = 7,
    CDK_Armor_Error = 8,
    CDK_Armor_CRC_Error = 9,
    CDK_MPI_Error = 10,
    CDK_Inv_Value = 11,
    CDK_Error_No_Key = 12,
    CDK_Chksum_Error = 13,
    CDK_Time_Conflict = 14,
    CDK_Zlib_Error = 15,
    CDK_Weak_Key = 16,
    CDK_Out_Of_Core = 17,
    CDK_Wrong_Seckey = 18,
    CDK_Bad_MDC = 19,
    CDK_Inv_Mode = 20,
    CDK_Error_No_Keyring = 21,
    CDK_Wrong_Format = 22,
    CDK_Inv_Packet_Ver = 23,
    CDK_Too_Short = 24,
    CDK_Unusable_Key = 25
} cdk_error_t;

enum cdk_packet_type_t

typedef enum {
    CDK_PKT_RESERVED      =  0,
    CDK_PKT_PUBKEY_ENC    =  1,
    CDK_PKT_SIGNATURE     =  2,
    CDK_PKT_SYMKEY_ENC    =  3,
    CDK_PKT_ONEPASS_SIG   =  4,
    CDK_PKT_SECRET_KEY    =  5,
    CDK_PKT_PUBLIC_KEY    =  6,
    CDK_PKT_SECRET_SUBKEY =  7,
    CDK_PKT_COMPRESSED    =  8,
    CDK_PKT_ENCRYPTED     =  9,
    CDK_PKT_MARKER        = 10,
    CDK_PKT_LITERAL       = 11,
    CDK_PKT_RING_TRUST    = 12,
    CDK_PKT_USER_ID       = 13,
    CDK_PKT_PUBLIC_SUBKEY = 14,
    CDK_PKT_OLD_COMMENT   = 16,
    CDK_PKT_ATTRIBUTE     = 17,
    CDK_PKT_ENCRYPTED_MDC = 18,
    CDK_PKT_MDC           = 19
} cdk_packet_type_t;

struct cdk_pkt_userid_s

struct cdk_pkt_userid_s {
    unsigned int len;
    unsigned is_primary:1;
    unsigned is_revoked:1;
    unsigned mdc_feature:1;
    cdk_prefitem_t prefs;
    unsigned char * attrib_img; /* Tag 17 if not null */
    size_t attrib_len;
    size_t prefs_size;
    unsigned int created;
    char name[1];
};

cdk_pkt_userid_t

typedef struct cdk_pkt_userid_s *cdk_pkt_userid_t;

struct cdk_pkt_pubkey_s

struct cdk_pkt_pubkey_s {
    unsigned char version;
    unsigned char pubkey_algo;
    unsigned char fpr[20];
    unsigned int keyid[2];
    unsigned int main_keyid[2];
    unsigned int timestamp;
    unsigned int expiredate;
    cdk_mpi_t mpi[4];
    unsigned is_revoked:1;
    unsigned is_invalid:1;
    unsigned has_expired:1;
    int pubkey_usage;
    cdk_pkt_userid_t uid;
    cdk_prefitem_t prefs;
    size_t prefs_size;
    cdk_desig_revoker_t revkeys;
};

cdk_pkt_pubkey_t

typedef struct cdk_pkt_pubkey_s *cdk_pkt_pubkey_t;

struct cdk_pkt_seckey_s

struct cdk_pkt_seckey_s {
    cdk_pkt_pubkey_t pk;
    unsigned int expiredate;
    int version;
    int pubkey_algo;
    unsigned int keyid[2];
    unsigned int main_keyid[2];
    unsigned char s2k_usage;
    struct {
        unsigned char algo;
        unsigned char sha1chk; /* SHA1 is used instead of a 16 bit checksum */
        cdk_s2k_t s2k;
        unsigned char iv[16];
        unsigned char ivlen;
    } protect;
    unsigned short csum;
    cdk_mpi_t mpi[4];
    unsigned char * encdata;
    size_t enclen;
    unsigned char is_protected;
    unsigned is_primary:1;
    unsigned has_expired:1;
    unsigned is_revoked:1;
};

cdk_pkt_seckey_t

typedef struct cdk_pkt_seckey_s *cdk_pkt_seckey_t;

struct cdk_pkt_signature_s

struct cdk_pkt_signature_s {
    unsigned char version;
    unsigned char sig_class;
    unsigned int timestamp;
    unsigned int expiredate;
    unsigned int keyid[2];
    unsigned char pubkey_algo;
    unsigned char digest_algo;
    unsigned char digest_start[2];
    unsigned short hashed_size;
    cdk_subpkt_t hashed;
    unsigned short unhashed_size;
    cdk_subpkt_t unhashed;
    cdk_mpi_t mpi[2];
    cdk_desig_revoker_t revkeys;
    struct {
        unsigned exportable:1;
        unsigned revocable:1;
        unsigned policy_url:1;
        unsigned notation:1;
        unsigned expired:1;
        unsigned checked:1;
        unsigned valid:1;
        unsigned missing_key:1;
    } flags;  
    unsigned int key[2]; /* only valid for key signatures */
};

cdk_pkt_signature_t

typedef struct cdk_pkt_signature_s *cdk_pkt_signature_t;

struct cdk_pkt_onepass_sig_s

struct cdk_pkt_onepass_sig_s {
    unsigned char version;
    unsigned int keyid[2];
    unsigned char sig_class;
    unsigned char digest_algo;
    unsigned char pubkey_algo;
    unsigned char last;
};

cdk_pkt_onepass_sig_t

typedef struct cdk_pkt_onepass_sig_s * cdk_pkt_onepass_sig_t;

struct cdk_pkt_pubkey_enc_s

struct cdk_pkt_pubkey_enc_s {
    unsigned char version;
    unsigned int keyid[2];
    int throw_keyid;
    unsigned char pubkey_algo;
    cdk_mpi_t mpi[2];
};

cdk_pkt_pubkey_enc_t

typedef struct cdk_pkt_pubkey_enc_s * cdk_pkt_pubkey_enc_t;

struct cdk_pkt_symkey_enc_s

struct cdk_pkt_symkey_enc_s {
    unsigned char version;
    unsigned char cipher_algo;
    cdk_s2k_t s2k;
    unsigned char seskeylen;
    unsigned char seskey[32];
};

cdk_pkt_symkey_enc_t

typedef struct cdk_pkt_symkey_enc_s *cdk_pkt_symkey_enc_t;

struct cdk_pkt_encrypted_s

struct cdk_pkt_encrypted_s {
    unsigned int len;
    int extralen;
    unsigned char mdc_method;
    cdk_stream_t buf;
};

cdk_pkt_encrypted_t

typedef struct cdk_pkt_encrypted_s *cdk_pkt_encrypted_t;

struct cdk_pkt_mdc_s

struct cdk_pkt_mdc_s {
    unsigned char hash[20];
};

cdk_pkt_mdc_t

typedef struct cdk_pkt_mdc_s *cdk_pkt_mdc_t;

struct cdk_pkt_literal_s

struct cdk_pkt_literal_s {
    unsigned int len;
    cdk_stream_t buf;
    int mode;
    unsigned int timestamp;
    int namelen;
    char name[1];
};

cdk_pkt_literal_t

typedef struct cdk_pkt_literal_s *cdk_pkt_literal_t;

struct cdk_pkt_compressed_s

struct cdk_pkt_compressed_s {
    unsigned int len;
    int algorithm;
    cdk_stream_t buf;
};

cdk_pkt_compressed_t

typedef struct cdk_pkt_compressed_s *cdk_pkt_compressed_t;

struct cdk_packet_s

struct cdk_packet_s {
    size_t pktlen; /* real packet length */
    size_t pktsize; /* length with all headers */
    int old_ctb;
    cdk_packet_type_t pkttype;
    union {
        cdk_pkt_mdc_t mdc;
        cdk_pkt_userid_t user_id;
        cdk_pkt_pubkey_t public_key;
        cdk_pkt_seckey_t secret_key;
        cdk_pkt_signature_t signature;
        cdk_pkt_pubkey_enc_t pubkey_enc;
        cdk_pkt_symkey_enc_t symkey_enc;
        cdk_pkt_compressed_t compressed;
        cdk_pkt_encrypted_t encrypted;
        cdk_pkt_literal_t literal;
        cdk_pkt_onepass_sig_t onepass_sig;
    } pkt;
};

CDK_PACKET

typedef struct cdk_packet_s CDK_PACKET;

cdk_packet_t

typedef struct cdk_packet_s *cdk_packet_t;

cdk_log_fnc_t ()

void        (*cdk_log_fnc_t)                (void *,
                                             ...,
                                             const char *,
                                             va_list );

cdk_set_log_level ()

void        cdk_set_log_level               (int lvl);

set the verbosity level.

cdk_set_log_handler ()

void        cdk_set_log_handler             (cdk_log_fnc_t logfnc,
                                             void *opaque);

set a private handler for logging.

cdk_strerror ()

const char* cdk_strerror                    (int ec);

Return an error text for the given id.

cdk_set_malloc_hooks ()

void        cdk_set_malloc_hooks            (void* (*new_alloc_func) (size_t n),
                                             void* (*new_alloc_secure_func) (size_t n),
                                             void* (*new_realloc_func) (void * p, size_t n),
                                             void* (*new_calloc_func) (size_t m, size_t n),
                                             void (*new_free_func) (void *));

Set private memory hooks for the lib.

cdk_malloc_hook_initialized ()

int         cdk_malloc_hook_initialized     (void);

Return if the malloc hooks are already initialized.

cdk_malloc ()

void*       cdk_malloc                      (size_t size);

cdk_calloc ()

void*       cdk_calloc                      (size_t n,
                                             size_t m);

cdk_realloc ()

void*       cdk_realloc                     (void *ptr,
                                             size_t size);

cdk_salloc ()

void*       cdk_salloc                      (size_t size,
                                             int clear);

cdk_strdup ()

char*       cdk_strdup                      (const char *ptr);

cdk_free ()

void        cdk_free                        (void *ptr);

cdk_handle_new ()

int         cdk_handle_new                  (cdk_ctx_t *r_ctx);

create a new session handle.

cdk_handle_free ()

void        cdk_handle_free                 (cdk_ctx_t hd);

free the main handle.

cdk_handle_set_keydb ()

void        cdk_handle_set_keydb            (cdk_ctx_t hd,
                                             cdk_keydb_hd_t db);

set the key database handle. the function automatically detects whether this is a public or secret keyring and the right handle is set.

cdk_handle_get_keydb ()

cdk_keydb_hd_t cdk_handle_get_keydb         (cdk_ctx_t hd,
                                             int type);

Return the keydb handle from the session handle.

cdk_handle_control ()

int         cdk_handle_control              (cdk_ctx_t hd,
                                             int action,
                                             int cmd,
                                             ...);

Perform various control operations for the current session.

cdk_handle_set_callback ()

void        cdk_handle_set_callback         (cdk_ctx_t hd,
                                             void (*cb) (void *opa, int type, const char * s),
                                             void *cb_value);

set the callback for filter operations.

cdk_handle_set_passphrase_cb ()

void        cdk_handle_set_passphrase_cb    (cdk_ctx_t hd,
                                             char* (*cb) (void *opa, const char *prompt),
                                             void *cb_value);

set the passphrase callback.

cdk_handle_set_armor()

#define     cdk_handle_set_armor( a, val )

cdk_handle_set_compress()

#define     cdk_handle_set_compress( a, algo, level )

cdk_set_progress_handler ()

void        cdk_set_progress_handler        (void (*cb) (void * hd, unsigned off,unsigned size),
                                             void *cb_value);

cdk_pkt_new ()

cdk_error_t cdk_pkt_new                     (cdk_packet_t *r_pkt);

cdk_pkt_init ()

void        cdk_pkt_init                    (cdk_packet_t pkt);

cdk_pkt_alloc ()

cdk_error_t cdk_pkt_alloc                   (cdk_packet_t *r_pkt,
                                             int pkttype);

cdk_pkt_free ()

void        cdk_pkt_free                    (cdk_packet_t pkt);

cdk_pkt_release ()

void        cdk_pkt_release                 (cdk_packet_t pkt);

cdk_pkt_read ()

cdk_error_t cdk_pkt_read                    (cdk_stream_t inp,
                                             cdk_packet_t pkt);

Parse the next packet on the inp stream and return its contents in pkt.

cdk_pkt_write ()

cdk_error_t cdk_pkt_write                   (cdk_stream_t out,
                                             cdk_packet_t pkt);

Write the contents of pkt into the out stream.

cdk_subpkt_new ()

cdk_subpkt_t cdk_subpkt_new                 (size_t size);

Create a new sub packet node with the size of size.

cdk_subpkt_free ()

void        cdk_subpkt_free                 (cdk_subpkt_t ctx);

Release the context.

cdk_subpkt_find ()

cdk_subpkt_t cdk_subpkt_find                (cdk_subpkt_t ctx,
                                             int type);

Find the given packet type in the node. If no packet with this type was found, return null otherwise pointer to the node.

cdk_subpkt_add ()

cdk_error_t cdk_subpkt_add                  (cdk_subpkt_t root,
                                             cdk_subpkt_t node);

Add the node in node to the root node root.

cdk_subpkt_get_data ()

const unsigned char* cdk_subpkt_get_data    (cdk_subpkt_t ctx,
                                             int *r_type,
                                             size_t *r_nbytes);

Extract the data from the given sub packet. The type is returned in r_type and the size in r_nbytes.

cdk_subpkt_init ()

void        cdk_subpkt_init                 (cdk_subpkt_t node,
                                             int type,
                                             const void *buf,
                                             size_t buflen);

Set the packet data of the given root and set the type of it.

cdk_userid_pref_get_array ()

unsigned char* cdk_userid_pref_get_array    (cdk_pkt_userid_t id,
                                             int type,
                                             size_t *ret_len);

cdk_key_desig_revoker_walk ()

const unsigned char* cdk_key_desig_revoker_walk
                                            (cdk_desig_revoker_t root,
                                             cdk_desig_revoker_t *ctx,
                                             int *r_class,
                                             int *r_algid);

is_RSA()

#define     is_RSA(a)

is_ELG()

#define is_ELG(a) ((a) == CDK_PK_ELG || (a) == CDK_PK_ELG_E)

is_DSA()

#define is_DSA(a) ((a) == CDK_PK_DSA)

cdk_pk_encrypt ()

cdk_error_t cdk_pk_encrypt                  (cdk_pkt_pubkey_t pk,
                                             cdk_pkt_pubkey_enc_t pke,
                                             cdk_sesskey_t esk);

Encrypt the session key in esk and write its encrypted content into the pke struct.

cdk_pk_decrypt ()

cdk_error_t cdk_pk_decrypt                  (cdk_pkt_seckey_t sk,
                                             cdk_pkt_pubkey_enc_t pke,
                                             cdk_sesskey_t *r_sk);

Decrypt the encrypted session key from pke into r_sk.

cdk_pk_sign ()

cdk_error_t cdk_pk_sign                     (cdk_pkt_seckey_t sk,
                                             cdk_pkt_signature_t sig,
                                             unsigned char *md);

Sign the message digest from md and write the result into sig.

cdk_pk_verify ()

cdk_error_t cdk_pk_verify                   (cdk_pkt_pubkey_t pk,
                                             cdk_pkt_signature_t sig,
                                             unsigned char *md);

Verify the signature in sig and compare it with the message digest in md.

cdk_pk_get_mpi ()

cdk_error_t cdk_pk_get_mpi                  (cdk_pkt_pubkey_t pk,
                                             int idx,
                                             unsigned char *buf,
                                             size_t *r_count,
                                             size_t *r_nbits);

cdk_sk_get_mpi ()

cdk_error_t cdk_sk_get_mpi                  (cdk_pkt_seckey_t sk,
                                             int idx,
                                             unsigned char *buf,
                                             size_t *r_count,
                                             size_t *r_nbits);

cdk_pk_get_nbits ()

int         cdk_pk_get_nbits                (cdk_pkt_pubkey_t pk);

cdk_pk_get_npkey ()

int         cdk_pk_get_npkey                (int algo);

cdk_pk_get_nskey ()

int         cdk_pk_get_nskey                (int algo);

cdk_pk_get_nsig ()

int         cdk_pk_get_nsig                 (int algo);

cdk_pk_get_nenc ()

int         cdk_pk_get_nenc                 (int algo);

cdk_pk_get_fingerprint ()

int         cdk_pk_get_fingerprint          (cdk_pkt_pubkey_t pk,
                                             unsigned char *fpr);

cdk_pk_fingerprint_get_keyid ()

unsigned int cdk_pk_fingerprint_get_keyid   (unsigned char *fpr,
                                             size_t fprlen,
                                             unsigned int *keyid);

cdk_pk_get_keyid ()

unsigned int cdk_pk_get_keyid               (cdk_pkt_pubkey_t pk,
                                             unsigned int *keyid);

cdk_sk_get_keyid ()

unsigned int cdk_sk_get_keyid               (cdk_pkt_seckey_t sk,
                                             unsigned int *keyid);

cdk_sig_get_keyid ()

unsigned int cdk_sig_get_keyid              (cdk_pkt_signature_t sig,
                                             unsigned int *keyid);

cdk_sk_unprotect ()

cdk_error_t cdk_sk_unprotect                (cdk_pkt_seckey_t sk,
                                             const char *pw);

cdk_sk_protect ()

cdk_error_t cdk_sk_protect                  (cdk_pkt_seckey_t sk,
                                             const char *pw);

cdk_pk_from_secret_key ()

cdk_error_t cdk_pk_from_secret_key          (cdk_pkt_seckey_t sk,
                                             cdk_pkt_pubkey_t *ret_pk);

Create a new public key from a secret key.

cdk_pubkey_to_sexp ()

cdk_error_t cdk_pubkey_to_sexp              (cdk_pkt_pubkey_t pk,
                                             char **sexp,
                                             size_t *len);

Convert a public key to an S-expression. sexp is allocated by this function, but you have to cdk_free() it yourself. The S-expression is stored in canonical format as used by libgcrypt (GCRYSEXP_FMT_CANON).

cdk_seckey_to_sexp ()

cdk_error_t cdk_seckey_to_sexp              (cdk_pkt_seckey_t sk,
                                             char **sexp,
                                             size_t *len);

Convert a public key to an S-expression. sexp is allocated by this function, but you have to cdk_free() it yourself. The S-expression is stored in canonical format as used by libgcrypt (GCRYSEXP_FMT_CANON).

cdk_sesskey_new ()

cdk_error_t cdk_sesskey_new                 (cdk_sesskey_t *r_sk);

cdk_sesskey_free ()

void        cdk_sesskey_free                (cdk_sesskey_t sk);

cdk_dek_new ()

cdk_error_t cdk_dek_new                     (cdk_dek_t *r_dek);

cdk_dek_free ()

void        cdk_dek_free                    (cdk_dek_t dek);

cdk_dek_set_cipher ()

cdk_error_t cdk_dek_set_cipher              (cdk_dek_t dek,
                                             int algo);

cdk_dek_set_key ()

cdk_error_t cdk_dek_set_key                 (cdk_dek_t dek,
                                             unsigned char *key,
                                             size_t keylen);

cdk_dek_from_passphrase ()

cdk_error_t cdk_dek_from_passphrase         (cdk_dek_t *ret_dek,
                                             int cipher_algo,
                                             cdk_s2k_t s2k,
                                             int mode,
                                             const char *pw);

cdk_dek_encode_pkcs1 ()

cdk_error_t cdk_dek_encode_pkcs1            (cdk_dek_t dek,
                                             int nbits,
                                             cdk_sesskey_t *r_esk);

cdk_dek_decode_pkcs1 ()

cdk_error_t cdk_dek_decode_pkcs1            (cdk_dek_t *ret_dek,
                                             cdk_sesskey_t esk);

cdk_dek_extract ()

cdk_error_t cdk_dek_extract                 (cdk_dek_t *ret_dek,
                                             cdk_ctx_t hd,
                                             cdk_pkt_pubkey_enc_t enc,
                                             cdk_pkt_seckey_t sk);

cdk_dek_set_mdc_flag ()

void        cdk_dek_set_mdc_flag            (cdk_dek_t dek,
                                             int val);

cdk_s2k_new ()

cdk_error_t cdk_s2k_new                     (cdk_s2k_t *ret_s2k,
                                             int mode,
                                             int algo,
                                             unsigned char *salt);

cdk_s2k_free ()

void        cdk_s2k_free                    (cdk_s2k_t s2k);

cdk_file_armor ()

cdk_error_t cdk_file_armor                  (cdk_ctx_t hd,
                                             const char *file,
                                             const char *output);

Protect a file with ASCII armor.

cdk_file_dearmor ()

cdk_error_t cdk_file_dearmor                (const char *file,
                                             const char *output);

Remove ASCII armor from a file.

cdk_armor_filter_use ()

cdk_error_t cdk_armor_filter_use            (cdk_stream_t inp);

Check if the stream contains armored data.

cdk_stream_control ()

int         cdk_stream_control              (cdk_stream_t s,
                                             int ctl,
                                             int val);

cdk_stream_open ()

cdk_error_t cdk_stream_open                 (const char *file,
                                             cdk_stream_t *ret_s);

cdk_stream_new ()

cdk_error_t cdk_stream_new                  (const char *file,
                                             cdk_stream_t *ret_s);

cdk_stream_create ()

cdk_error_t cdk_stream_create               (const char *file,
                                             cdk_stream_t *ret_s);

The difference to cdk_stream_new is, that no filtering can be used with this kind of stream and everything is written directly to the stream.

cdk_stream_tmp ()

cdk_stream_t cdk_stream_tmp                 (void);

cdk_stream_tmp_from_mem ()

cdk_stream_t cdk_stream_tmp_from_mem        (const void *buf,
                                             size_t count);

cdk_stream_tmp_set_mode ()

void        cdk_stream_tmp_set_mode         (cdk_stream_t s,
                                             int val);

cdk_stream_flush ()

cdk_error_t cdk_stream_flush                (cdk_stream_t s);

cdk_stream_set_cache ()

cdk_error_t cdk_stream_set_cache            (cdk_stream_t s,
                                             int val);

cdk_stream_filter_disable ()

cdk_error_t cdk_stream_filter_disable       (cdk_stream_t s,
                                             int type);

cdk_stream_close ()

cdk_error_t cdk_stream_close                (cdk_stream_t s);

This function work different for read or write streams. When the stream is for reading, the filtering is already done and we can simply close the file and all buffers. But for the case it's a write stream, we need to apply all registered filters now. The file is closed in the filter function and not here.

cdk_stream_get_length ()

unsigned    cdk_stream_get_length           (cdk_stream_t s);

This file only works for read stream because it's likely that the write stream is not flushed or even no data was inserted.

cdk_stream_read ()

int         cdk_stream_read                 (cdk_stream_t s,
                                             void *buf,
                                             size_t count);

When this function is called the first time, it can take a while because all filters need to be processed. Please remember that you need to add the filters in reserved order.

cdk_stream_write ()

int         cdk_stream_write                (cdk_stream_t s,
                                             const void *buf,
                                             size_t count);

In this function we simply write the bytes to the stream. We can't use the filters here because it would mean they have to support partial flushing.

cdk_stream_putc ()

int         cdk_stream_putc                 (cdk_stream_t s,
                                             int c);

cdk_stream_getc ()

int         cdk_stream_getc                 (cdk_stream_t s);

cdk_stream_eof ()

int         cdk_stream_eof                  (cdk_stream_t s);

This function will only work with read streams.

cdk_stream_tell ()

long        cdk_stream_tell                 (cdk_stream_t s);

cdk_stream_seek ()

cdk_error_t cdk_stream_seek                 (cdk_stream_t s,
                                             long offset );

cdk_stream_set_armor_flag ()

cdk_error_t cdk_stream_set_armor_flag       (cdk_stream_t s,
                                             int type);

cdk_stream_set_literal_flag ()

cdk_error_t cdk_stream_set_literal_flag     (cdk_stream_t s,
                                             int mode,
                                             const char *fname);

cdk_stream_set_cipher_flag ()

cdk_error_t cdk_stream_set_cipher_flag      (cdk_stream_t s,
                                             cdk_dek_t dek,
                                             int use_mdc);

cdk_stream_set_compress_flag ()

cdk_error_t cdk_stream_set_compress_flag    (cdk_stream_t s,
                                             int algo,
                                             int level);

cdk_stream_set_hash_flag ()

cdk_error_t cdk_stream_set_hash_flag        (cdk_stream_t s,
                                             int algo);

cdk_stream_set_text_flag ()

cdk_error_t cdk_stream_set_text_flag        (cdk_stream_t s,
                                             const char *lf);

cdk_stream_kick_off ()

cdk_error_t cdk_stream_kick_off             (cdk_stream_t inp,
                                             cdk_stream_t out);

cdk_stream_mmap ()

cdk_error_t cdk_stream_mmap                 (cdk_stream_t s,
                                             unsigned char **ret_buf,
                                             size_t *ret_count);

Map the data of the given stream into a memory section. ret_count contains the length of the buffer.

cdk_stream_peek ()

int         cdk_stream_peek                 (cdk_stream_t inp,
                                             unsigned char *s,
                                             size_t count);

The function acts like cdk_stream_read with the difference that the file pointer is moved to the old position after the bytes were read.

cdk_keydb_new ()

cdk_error_t cdk_keydb_new                   (cdk_keydb_hd_t *r_hd,
                                             int type,
                                             void *data,
                                             size_t count);

Create a new keydb object

cdk_keydb_open ()

cdk_error_t cdk_keydb_open                  (cdk_keydb_hd_t hd,
                                             cdk_stream_t *ret_kr);

Open a STREAM with the contents of the keyring from hd

cdk_keydb_check_sk ()

int         cdk_keydb_check_sk              (cdk_keydb_hd_t hd,
                                             unsigned int *keyid);

cdk_keydb_search_start ()

cdk_error_t cdk_keydb_search_start          (cdk_keydb_hd_t db,
                                             int type,
                                             void *desc);

Create a new keydb search object.

cdk_keydb_search ()

cdk_error_t cdk_keydb_search                (cdk_keydb_hd_t hd,
                                             cdk_kbnode_t *ret_key);

Search for a key in the given keyring. If the key was found, ret_key contains the key data.

cdk_keydb_free ()

void        cdk_keydb_free                  (cdk_keydb_hd_t hd);

Free the keydb object.

cdk_keydb_get_bykeyid ()

cdk_error_t cdk_keydb_get_bykeyid           (cdk_keydb_hd_t hd,
                                             unsigned int *keyid,
                                             cdk_kbnode_t *ret_pk);

cdk_keydb_get_byfpr ()

cdk_error_t cdk_keydb_get_byfpr             (cdk_keydb_hd_t hd,
                                             unsigned char *fpr,
                                             cdk_kbnode_t *ret_pk);

cdk_keydb_get_bypattern ()

cdk_error_t cdk_keydb_get_bypattern         (cdk_keydb_hd_t hd,
                                             const char *patt,
                                             cdk_kbnode_t *ret_pk);

cdk_keydb_get_pk ()

cdk_error_t cdk_keydb_get_pk                (cdk_keydb_hd_t khd,
                                             unsigned int *keyid,
                                             cdk_pkt_pubkey_t *ret_pk);

cdk_keydb_get_sk ()

cdk_error_t cdk_keydb_get_sk                (cdk_keydb_hd_t khd,
                                             unsigned int *keyid,
                                             cdk_pkt_seckey_t *ret_sk);

cdk_keydb_get_keyblock ()

cdk_error_t cdk_keydb_get_keyblock          (cdk_stream_t inp,
                                             cdk_kbnode_t *ret_key);

cdk_keydb_idx_rebuild ()

cdk_error_t cdk_keydb_idx_rebuild           (cdk_keydb_hd_t hd);

Rebuild the key index files for the given key database.

cdk_keydb_export ()

cdk_error_t cdk_keydb_export                (cdk_keydb_hd_t hd,
                                             cdk_stream_t out,
                                             cdk_strlist_t remusr);

cdk_keydb_import ()

cdk_error_t cdk_keydb_import                (cdk_keydb_hd_t hd,
                                             cdk_kbnode_t knode,
                                             int *result);

cdk_keydb_pk_cache_sigs ()

cdk_error_t cdk_keydb_pk_cache_sigs         (cdk_kbnode_t pk,
                                             cdk_keydb_hd_t hd);

cdk_listkey_start ()

cdk_error_t cdk_listkey_start               (cdk_listkey_t *r_ctx,
                                             cdk_keydb_hd_t db,
                                             const char *patt,
                                             cdk_strlist_t fpatt);

Prepare a key listing with the given parameters. Two modes are supported. The first mode uses string pattern to determine if the key should be returned or not. The other mode uses a string list to request the key which should be listed.

cdk_listkey_close ()

void        cdk_listkey_close               (cdk_listkey_t ctx);

Free the list key context.

cdk_listkey_next ()

cdk_error_t cdk_listkey_next                (cdk_listkey_t ctx,
                                             cdk_kbnode_t *ret_key);

Retrieve the next key from the pattern of the key list context.

cdk_kbnode_new ()

cdk_kbnode_t cdk_kbnode_new                 (cdk_packet_t pkt);

Allocate a new key node and add the packet.

cdk_kbnode_read_from_mem ()

cdk_error_t cdk_kbnode_read_from_mem        (cdk_kbnode_t *ret_node,
                                             unsigned char *buf,
                                             size_t buflen);

Try to read a key node from the memory buffer buf.

cdk_kbnode_write_to_mem ()

cdk_error_t cdk_kbnode_write_to_mem         (cdk_kbnode_t node,
                                             unsigned char *buf,
                                             size_t *r_nbytes);

Try to write the contents of the key node to the buffer buf and return the length of it in r_nbytes. If buf is zero, only the length of the node is calculated and returned in r_nbytes.

cdk_kbnode_release ()

void        cdk_kbnode_release              (cdk_kbnode_t node);

Release the memory of the node.

cdk_kbnode_walk ()

cdk_kbnode_t cdk_kbnode_walk                (cdk_kbnode_t root,
                                             cdk_kbnode_t *ctx,
                                             int all);

cdk_kbnode_find_packet ()

cdk_packet_t cdk_kbnode_find_packet         (cdk_kbnode_t node,
                                             int pkttype);

Same as cdk_kbnode_find but it returns the packet instead of the node.

cdk_kbnode_get_packet ()

cdk_packet_t cdk_kbnode_get_packet          (cdk_kbnode_t node);

Return the packet which is stored inside the node in node.

cdk_kbnode_find ()

cdk_kbnode_t cdk_kbnode_find                (cdk_kbnode_t node,
                                             int pkttype);

Try to find the next node with the packettype pkttype.

cdk_kbnode_find_prev ()

cdk_kbnode_t cdk_kbnode_find_prev           (cdk_kbnode_t root,
                                             cdk_kbnode_t node,
                                             int pkttype);

Find the previous node (if pkttype = 0) or the previous node with pkttype pkttype in the list starting with root of node.

cdk_kbnode_find_next ()

cdk_kbnode_t cdk_kbnode_find_next           (cdk_kbnode_t node,
                                             int pkttype);

Ditto, but find the next packet. The behaviour is trivial if pkttype is 0 but if it is specified, the next node with a packet of this type is returned. The function has some knowledge about the valid ordering of packets: e.g. if the next signature packet is requested, the function will not return one if it encounters a user-id.

cdk_kbnode_get_attr ()

void*       cdk_kbnode_get_attr             (cdk_kbnode_t node,
                                             int pkttype,
                                             int attr);

Extract a single attribute from the specified packet type. If no packet type is given, it is assumed that the public key is meant. If the attr was found, it is returned as a pointer which can be cast to a proper type.

cdk_kbnode_hash ()

cdk_error_t cdk_kbnode_hash                 (cdk_kbnode_t node,
                                             cdk_md_hd_t md,
                                             int is_v4,
                                             int pkttype,
                                             int flags);

Hash the key node contents. Two modes are supported. If the packet type is used (!= 0) then the function searches the first node with this type. Otherwise the node is seen as a single node and the type is extracted from it.

cdk_pk_check_sigs ()

cdk_error_t cdk_pk_check_sigs               (cdk_kbnode_t knode,
                                             cdk_keydb_hd_t hd,
                                             int *r_status);

Check all signatures. When no key is available for checking, the sigstat is marked as 'NOKEY'. The r_status contains the key flags which are or-ed or zero when there are no flags.

cdk_pklist_select_algo ()

int         cdk_pklist_select_algo          (cdk_keylist_t pkl,
                                             int preftype);

Select a symmetric cipher algorithm from a list of public keys. This algorithm is present in all key preferences.

cdk_pklist_use_mdc ()

int         cdk_pklist_use_mdc              (cdk_keylist_t pkl);

cdk_pklist_build ()

cdk_error_t cdk_pklist_build                (cdk_keylist_t *ret_pkl,
                                             cdk_keydb_hd_t hd,
                                             cdk_strlist_t remusr,
                                             int use);

Create a public key list based on the recipient names in remusr.

cdk_pklist_release ()

void        cdk_pklist_release              (cdk_keylist_t pkl);

Free the memory of the key list.

cdk_pklist_encrypt ()

cdk_error_t cdk_pklist_encrypt              (cdk_keylist_t pk_list,
                                             cdk_dek_t dek,
                                             cdk_stream_t outp);

Encrypt the session key with each key of the list and wrap it into a PUBKEY_ENC packet and write it to outp.

cdk_sklist_build ()

cdk_error_t cdk_sklist_build                (cdk_keylist_t *ret_skl,
                                             cdk_keydb_hd_t db,
                                             cdk_ctx_t hd,
                                             cdk_strlist_t locusr,
                                             int unlock,
                                             unsigned int use);

cdk_sklist_release ()

void        cdk_sklist_release              (cdk_keylist_t skl);

Free the memory of the secret keylist.

cdk_sklist_write ()

cdk_error_t cdk_sklist_write                (cdk_keylist_t skl,
                                             cdk_stream_t outp,
                                             cdk_md_hd_t hash,
                                             int sigclass,
                                             int sigver);

Complete the sig based on hash and write all signatures to outp.

cdk_sklist_write_onepass ()

cdk_error_t cdk_sklist_write_onepass        (cdk_keylist_t skl,
                                             cdk_stream_t outp,
                                             int sigclass,
                                             int mdalgo);

Write a one-pass signature for each key in the list into outp.

cdk_stream_encrypt ()

cdk_error_t cdk_stream_encrypt              (cdk_ctx_t hd,
                                             cdk_strlist_t remusr,
                                             cdk_stream_t inp,
                                             cdk_stream_t out);

If remusr is NULL, then symmetric encryption is used. Via the handle the caller can set or unset multiple options.

cdk_stream_decrypt ()

cdk_error_t cdk_stream_decrypt              (cdk_ctx_t hd,
                                             cdk_stream_t inp,
                                             cdk_stream_t out);

cdk_file_encrypt ()

cdk_error_t cdk_file_encrypt                (cdk_ctx_t hd,
                                             cdk_strlist_t remusr,
                                             const char *file,
                                             const char *output);

cdk_file_decrypt ()

cdk_error_t cdk_file_decrypt                (cdk_ctx_t hd,
                                             const char *file,
                                             const char *output);

When the operation was successfull, hd can contain information about the signature (when present) and more.

cdk_data_transform ()

cdk_error_t cdk_data_transform              (cdk_ctx_t hd,
                                             enum cdk_crypto_mode_t mode,
                                             cdk_strlist_t locusr,
                                             cdk_strlist_t remusr,
                                             const void *inbuf,
                                             size_t insize,
                                             unsigned char **outbuf,
                                             size_t *outsize,
                                             int modval);

This function transforms data into the given openpgp mode. It works exactly like the cdk_file_xxx functions with the exception that it can be used with memory and not with streams or files.

cdk_stream_sign ()

cdk_error_t cdk_stream_sign                 (cdk_ctx_t hd,
                                             cdk_stream_t inp,
                                             cdk_stream_t out,
                                             cdk_strlist_t locusr,
                                             cdk_strlist_t remusr,
                                             int encryptflag,
                                             int sigmode);

Sign the data from the STREAM inp.

cdk_file_sign ()

cdk_error_t cdk_file_sign                   (cdk_ctx_t hd,
                                             cdk_strlist_t locusr,
                                             cdk_strlist_t remusr,
                                             const char *file,
                                             const char *output,
                                             int sigmode,
                                             int encryptflag);

Sign a file.

cdk_stream_verify ()

cdk_error_t cdk_stream_verify               (cdk_ctx_t hd,
                                             cdk_stream_t inp,
                                             cdk_stream_t out);

cdk_file_verify ()

cdk_error_t cdk_file_verify                 (cdk_ctx_t hd,
                                             const char *file,
                                             const char *output);

Verify a signature.

cdk_sig_get_ulong_attr ()

unsigned long cdk_sig_get_ulong_attr        (cdk_ctx_t hd,
                                             int idx,
                                             int what);

Extract the requested attribute of the signature. The returned value is always an integer (max. 32-bit).

cdk_sig_get_data_attr ()

const void* cdk_sig_get_data_attr           (cdk_ctx_t hd,
                                             int idx,
                                             int what);

Extract the requested attribute of the signature. The returned value is always a constant object to the data.

cdk_trustdb_get_validity ()

int         cdk_trustdb_get_validity        (cdk_stream_t inp,
                                             cdk_pkt_userid_t id,
                                             int *r_val);

cdk_trustdb_get_ownertrust ()

int         cdk_trustdb_get_ownertrust      (cdk_stream_t inp,
                                             cdk_pkt_pubkey_t pk,
                                             int *r_val,
                                             int *r_flags);

cdk_strlist_free ()

void        cdk_strlist_free                (cdk_strlist_t sl);

cdk_strlist_add ()

cdk_strlist_t cdk_strlist_add               (cdk_strlist_t *list,
                                             const char *string);

cdk_strlist_walk ()

const char* cdk_strlist_walk                (cdk_strlist_t root,
                                             cdk_strlist_t *context);

cdk_check_version ()

const char* cdk_check_version               (const char *req_version);

Check that the the version of the library is at minimum the requested one and return the version string; return NULL if the condition is not satisfied. If a NULL is passed to this function, no check is done, but the version string is simply returned.

cdk_utf8_encode ()

char*       cdk_utf8_encode                 (const char *string);

cdk_utf8_decode ()

char*       cdk_utf8_decode                 (const char *string,
                                             size_t length,
                                             int delim);

cdk_keyserver_recv_key ()

cdk_error_t cdk_keyserver_recv_key          (const char *host,
                                             int port,
                                             unsigned char *keyid,
                                             int kid_type,
                                             cdk_kbnode_t *ret_key);

Receive a key from a keyserver.

cdk_keygen_new ()

cdk_error_t cdk_keygen_new                  (cdk_keygen_ctx_t *r_hd);

cdk_keygen_free ()

void        cdk_keygen_free                 (cdk_keygen_ctx_t hd);

cdk_keygen_set_prefs ()

cdk_error_t cdk_keygen_set_prefs            (cdk_keygen_ctx_t hd,
                                             enum cdk_pref_type_t type,
                                             unsigned char *array,
                                             size_t n);

cdk_keygen_set_algo_info ()

cdk_error_t cdk_keygen_set_algo_info        (cdk_keygen_ctx_t hd,
                                             int type,
                                             enum cdk_pk_algo_t algo,
                                             int bits);

cdk_keygen_set_mdc_feature ()

void        cdk_keygen_set_mdc_feature      (cdk_keygen_ctx_t hd,
                                             int val);

if you want a RFC2440 compliant key, you've to disable this feature until the rfc2440-bis8 becomes the next standard.

cdk_keygen_set_keyserver_flags ()

void        cdk_keygen_set_keyserver_flags  (cdk_keygen_ctx_t hd,
                                             int no_modify,
                                             const char *pref_url);

cdk_keygen_set_expire_date ()

void        cdk_keygen_set_expire_date      (cdk_keygen_ctx_t hd,
                                             int type,
                                             long int timestamp);

cdk_keygen_set_name ()

void        cdk_keygen_set_name             (cdk_keygen_ctx_t hd,
                                             const char *name);

The name will be encoded in UTF8 to avoid problems.

cdk_keygen_set_passphrase ()

void        cdk_keygen_set_passphrase       (cdk_keygen_ctx_t hd,
                                             const char *pass);

cdk_keygen_start ()

cdk_error_t cdk_keygen_start                (cdk_keygen_ctx_t hd);

cdk_keygen_save ()

cdk_error_t cdk_keygen_save                 (cdk_keygen_ctx_t hd,
                                             const char *pubf,
                                             const char *secf);