## CamelCipherContext CamelCipherContext |

## Synopsis

                        CamelCipherContext;
                        CamelCipherValidity;
                        CamelCipherCertInfo;
    enum                CamelCipherHash;
    enum                camel_cipher_validity_sign_t;
    enum                camel_cipher_validity_encrypt_t;
    enum                camel_cipher_validity_mode_t;
    CamelCipherContext* camel_cipher_context_new            (CamelSession *session);
    void                camel_cipher_context_construct      (CamelCipherContext *context,
                                                             CamelSession *session);
    CamelCipherHash     camel_cipher_id_to_hash             (CamelCipherContext *context,
                                                             const char *id);
    const char*         camel_cipher_hash_to_id             (CamelCipherContext *context,
                                                             CamelCipherHash hash);
    int                 camel_cipher_sign                   (CamelCipherContext *context,
                                                             const char *userid,
                                                             CamelCipherHash hash,
                                                             struct _CamelMimePart *ipart,
                                                             struct _CamelMimePart *opart,
                                                             CamelException *ex);
    CamelCipherValidity* camel_cipher_verify                (CamelCipherContext *context,
                                                             struct _CamelMimePart *ipart,
                                                             CamelException *ex);
    int                 camel_cipher_encrypt                (CamelCipherContext *context,
                                                             const char *userid,
                                                             GPtrArray *recipients,
                                                             struct _CamelMimePart *ipart,
                                                             struct _CamelMimePart *opart,
                                                             CamelException *ex);
    CamelCipherValidity* camel_cipher_decrypt               (CamelCipherContext *context,
                                                             struct _CamelMimePart *ipart,
                                                             struct _CamelMimePart *opart,
                                                             CamelException *ex);
    int                 camel_cipher_import_keys            (CamelCipherContext *context,
                                                             struct _CamelStream *istream,
                                                             CamelException *ex);
    int                 camel_cipher_export_keys            (CamelCipherContext *context,
                                                             GPtrArray *keys,
                                                             struct _CamelStream *ostream,
                                                             CamelException *ex);
    CamelCipherValidity* camel_cipher_validity_new          (void);
    void                camel_cipher_validity_init          (CamelCipherValidity *validity);
    gboolean            camel_cipher_validity_get_valid     (CamelCipherValidity *validity);
    void                camel_cipher_validity_set_valid     (CamelCipherValidity *validity,
                                                             gboolean valid);
    char*               camel_cipher_validity_get_description
                                                            (CamelCipherValidity *validity);
    void                camel_cipher_validity_set_description
                                                            (CamelCipherValidity *validity,
                                                             const char *description);
    void                camel_cipher_validity_clear         (CamelCipherValidity *validity);
    CamelCipherValidity* camel_cipher_validity_clone        (CamelCipherValidity *vin);
    void                camel_cipher_validity_add_certinfo  (CamelCipherValidity *vin,
                                                             camel_cipher_validity_mode_t mode,
                                                             const char *name,
                                                             const char *email);
    void                camel_cipher_validity_envelope      (CamelCipherValidity *valid,
                                                             CamelCipherValidity *outer);
    void                camel_cipher_validity_free          (CamelCipherValidity *validity);
    int                 camel_cipher_canonical_to_stream    (CamelMimePart *part,
                                                             guint32 flags,
                                                             CamelStream *ostream);

## Description

## Details

### CamelCipherContext

    typedef struct {
    	CamelObject parent_object;

    	struct _CamelCipherContextPrivate *priv;

    	CamelSession *session;

    	/* these MUST be set by implementors */
    	const char *sign_protocol;
    	const char *encrypt_protocol;
    	const char *key_protocol;
    } CamelCipherContext;

### CamelCipherValidity

    typedef struct {
    	struct _CamelCipherValidity *next;
    	struct _CamelCipherValidity *prev;
    	EDList children;

    	struct {
    		enum _camel_cipher_validity_sign_t status;
    		char *description;
    		EDList signers;	/* CamelCipherCertInfo's */
    	} sign;
    	struct {
    		enum _camel_cipher_validity_encrypt_t status;
    		char *description;
    		EDList encrypters;	/* CamelCipherCertInfo's */
    	} encrypt;
    } CamelCipherValidity;

### CamelCipherCertInfo

    typedef struct {
    	struct _CamelCipherCertInfo *next;
    	struct _CamelCipherCertInfo *prev;

    	char *name;		/* common name */
    	char *email;
    } CamelCipherCertInfo;

### enum CamelCipherHash

    typedef enum {
    	CAMEL_CIPHER_HASH_DEFAULT,
    	CAMEL_CIPHER_HASH_MD2,
    	CAMEL_CIPHER_HASH_MD5,
    	CAMEL_CIPHER_HASH_SHA1,
    	CAMEL_CIPHER_HASH_RIPEMD160,
    	CAMEL_CIPHER_HASH_TIGER192,
    	CAMEL_CIPHER_HASH_HAVAL5160
    } CamelCipherHash;

### enum camel_cipher_validity_sign_t

    typedef enum _camel_cipher_validity_sign_t {
    	CAMEL_CIPHER_VALIDITY_SIGN_NONE,
    	CAMEL_CIPHER_VALIDITY_SIGN_GOOD,
    	CAMEL_CIPHER_VALIDITY_SIGN_BAD,
    	CAMEL_CIPHER_VALIDITY_SIGN_UNKNOWN,
    	CAMEL_CIPHER_VALIDITY_SIGN_NEED_PUBLIC_KEY
    } camel_cipher_validity_sign_t;

### enum camel_cipher_validity_encrypt_t

    typedef enum _camel_cipher_validity_encrypt_t {
    	CAMEL_CIPHER_VALIDITY_ENCRYPT_NONE,
    	CAMEL_CIPHER_VALIDITY_ENCRYPT_WEAK,
    	CAMEL_CIPHER_VALIDITY_ENCRYPT_ENCRYPTED, /* encrypted, unknown strenght */
    	CAMEL_CIPHER_VALIDITY_ENCRYPT_STRONG
    } camel_cipher_validity_encrypt_t;

### enum camel_cipher_validity_mode_t

    typedef enum _camel_cipher_validity_mode_t {
    	CAMEL_CIPHER_VALIDITY_SIGN,
    	CAMEL_CIPHER_VALIDITY_ENCRYPT
    } camel_cipher_validity_mode_t;

### camel_cipher_context_new ()

    CamelCipherContext* camel_cipher_context_new            (CamelSession *session);

This creates a new CamelCipherContext object which is used to sign, verify, encrypt and decrypt streams.

`session` : | CamelSession
Returns : | the new CamelCipherContext

### camel_cipher_context_construct ()

    void                camel_cipher_context_construct      (CamelCipherContext *context,
                                                             CamelSession *session);

Constucts the CamelCipherContext

`context` : | CamelCipherContext
`session` : | CamelSession

### camel_cipher_id_to_hash ()

    CamelCipherHash     camel_cipher_id_to_hash             (CamelCipherContext *context,
                                                             const char *id);

`context` : |
`id` : |
Returns : |

### camel_cipher_hash_to_id ()

    const char*         camel_cipher_hash_to_id             (CamelCipherContext *context,
                                                             CamelCipherHash hash);

`context` : |
`hash` : |
Returns : |

### camel_cipher_sign ()

    int                 camel_cipher_sign                   (CamelCipherContext *context,
                                                             const char *userid,
                                                             CamelCipherHash hash,
                                                             struct _CamelMimePart *ipart,
                                                             struct _CamelMimePart *opart,
                                                             CamelException *ex);

Converts the (unsigned) part `ipart` into a new self-contained mime part `opart`. This may be a multipart/signed part, or a simple part for enveloped types.

`context` : | Cipher Context
`userid` : | private key to use to sign the stream
`hash` : | preferred Message-Integrity-Check hash algorithm
`ipart` : | Input part.
`opart` : | output part.
`ex` : | exception
Returns : | 0 for success or -1 for failure.

### camel_cipher_verify ()

    CamelCipherValidity* camel_cipher_verify                (CamelCipherContext *context,
                                                             struct _CamelMimePart *ipart,
                                                             CamelException *ex);

Verifies the signature. If `istream` is a clearsigned stream, you should pass `NULL` as the sigstream parameter. Otherwise `sigstream` is assumed to be the signature stream and is used to verify the integirity of the `istream`.

`context` : | Cipher Context
`ipart` : | part to verify
`ex` : | exception
Returns : | a CamelCipherValidity structure containing information about the integrity of the input stream or `NULL` on failure to execute at all.

### camel_cipher_encrypt ()

    int                 camel_cipher_encrypt                (CamelCipherContext *context,
                                                             const char *userid,
                                                             GPtrArray *recipients,
                                                             struct _CamelMimePart *ipart,
                                                             struct _CamelMimePart *opart,
                                                             CamelException *ex);

Encrypts (and optionally signs) the cleartext input stream and writes the resulting ciphertext to the output stream.

`context` : | Cipher Context
`userid` : | key id (or email address) to use when signing, or NULL to not sign.
`recipients` : | an array of recipient key ids and/or email addresses
`ipart` : | cleartext input stream
`opart` : | ciphertext output stream
`ex` : | exception
Returns : | 0 for success or -1 for failure.

### camel_cipher_decrypt ()

    CamelCipherValidity* camel_cipher_decrypt               (CamelCipherContext *context,
                                                             struct _CamelMimePart *ipart,
                                                             struct _CamelMimePart *opart,
                                                             CamelException *ex);

Decrypts `ipart` into `opart`.

`context` : |
`ipart` : |
`opart` : |
`ex` : |
Returns : | A validity/encryption status.

### camel_cipher_import_keys ()

    int                 camel_cipher_import_keys            (CamelCipherContext *context,
                                                             struct _CamelStream *istream,
                                                             CamelException *ex);

Imports a stream of keys/certificates contained within `istream` into the key/certificate database controlled by `ctx`.

`context` : | Cipher Context
`istream` : | input stream (containing keys)
`ex` : | exception
Returns : | 0 on success or -1 on fail.

### camel_cipher_export_keys ()

    int                 camel_cipher_export_keys            (CamelCipherContext *context,
                                                             GPtrArray *keys,
                                                             struct _CamelStream *ostream,
                                                             CamelException *ex);

Exports the keys/certificates in `keys` to the stream `ostream` from the key/certificate database controlled by `ctx`.

`context` : | Cipher Context
`keys` : | an array of key ids
`ostream` : | output stream
`ex` : | exception
Returns : | 0 on success or -1 on fail.

### camel_cipher_validity_new ()

    CamelCipherValidity* camel_cipher_validity_new          (void);

Returns : |

### camel_cipher_validity_init ()

    void                camel_cipher_validity_init          (CamelCipherValidity *validity);

`validity` : |

### camel_cipher_validity_get_valid ()

    gboolean            camel_cipher_validity_get_valid     (CamelCipherValidity *validity);

`validity` : |
Returns : |

### camel_cipher_validity_set_valid ()

    void                camel_cipher_validity_set_valid     (CamelCipherValidity *validity,
                                                             gboolean valid);

`validity` : |
`valid` : |

### camel_cipher_validity_get_description ()

    char*               camel_cipher_validity_get_description
                                                            (CamelCipherValidity *validity);

`validity` : |
Returns : |

### camel_cipher_validity_set_description ()

    void                camel_cipher_validity_set_description
                                                            (CamelCipherValidity *validity,
                                                             const char *description);

`validity` : |
`description` : |

### camel_cipher_validity_clear ()

    void                camel_cipher_validity_clear         (CamelCipherValidity *validity);

`validity` : |

### camel_cipher_validity_clone ()

    CamelCipherValidity* camel_cipher_validity_clone        (CamelCipherValidity *vin);

`vin` : |
Returns : |

### camel_cipher_validity_add_certinfo ()

    void                camel_cipher_validity_add_certinfo  (CamelCipherValidity *vin,
                                                             camel_cipher_validity_mode_t mode,
                                                             const char *name,
                                                             const char *email);

Add a cert info to the signer or encrypter info.

`vin` : |
`mode` : |
`name` : |
`email` : |

### camel_cipher_validity_envelope ()

    void                camel_cipher_validity_envelope      (CamelCipherValidity *valid,
                                                             CamelCipherValidity *outer);

Calculate a conglomerate validity based on wrapping one secure part inside another one.

`valid` : |
`outer` : |

### camel_cipher_validity_free ()

    void                camel_cipher_validity_free          (CamelCipherValidity *validity);

`validity` : |

### camel_cipher_canonical_to_stream ()

    int                 camel_cipher_canonical_to_stream    (CamelMimePart *part,
                                                             guint32 flags,
                                                             CamelStream *ostream);

Writes a part to a stream in a canonicalised format, suitable for signing/encrypting.

The transfer encoding paramaters for the part may be changed by this function.

`part` : | Part to write.
`flags` : | flags for the canonicalisation filter (CamelMimeFilterCanon)
`ostream` : | stream to write canonicalised output to.
Returns : | -1 on error;