pk.h

Go to the documentation of this file.

 
#ifndef POLARSSL_PK_H
#define POLARSSL_PK_H
 
#if !defined(POLARSSL_CONFIG_FILE)
#include "config.h"
#else
#include POLARSSL_CONFIG_FILE
#endif
 
#include "md.h"
 
#if defined(POLARSSL_RSA_C)
#include "rsa.h"
#endif
 
#if defined(POLARSSL_ECP_C)
#include "ecp.h"
#endif
 
#if defined(POLARSSL_ECDSA_C)
#include "ecdsa.h"
#endif
 
#define POLARSSL_ERR_PK_MALLOC_FAILED       -0x2F80  
#define POLARSSL_ERR_PK_TYPE_MISMATCH       -0x2F00  
#define POLARSSL_ERR_PK_BAD_INPUT_DATA      -0x2E80  
#define POLARSSL_ERR_PK_FILE_IO_ERROR       -0x2E00  
#define POLARSSL_ERR_PK_KEY_INVALID_VERSION -0x2D80  
#define POLARSSL_ERR_PK_KEY_INVALID_FORMAT  -0x2D00  
#define POLARSSL_ERR_PK_UNKNOWN_PK_ALG      -0x2C80  
#define POLARSSL_ERR_PK_PASSWORD_REQUIRED   -0x2C00  
#define POLARSSL_ERR_PK_PASSWORD_MISMATCH   -0x2B80  
#define POLARSSL_ERR_PK_INVALID_PUBKEY      -0x2B00  
#define POLARSSL_ERR_PK_INVALID_ALG         -0x2A80  
#define POLARSSL_ERR_PK_UNKNOWN_NAMED_CURVE -0x2A00  
#define POLARSSL_ERR_PK_FEATURE_UNAVAILABLE -0x2980  
#define POLARSSL_ERR_PK_SIG_LEN_MISMATCH    -0x2000  
#if defined(POLARSSL_RSA_C)
#define pk_rsa( pk )        ( (rsa_context *) (pk).pk_ctx )
#endif /* POLARSSL_RSA_C */
 
#if defined(POLARSSL_ECP_C)
#define pk_ec( pk )         ( (ecp_keypair *) (pk).pk_ctx )
#endif /* POLARSSL_ECP_C */
 
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum {
    POLARSSL_PK_NONE=0,
    POLARSSL_PK_RSA,
    POLARSSL_PK_ECKEY,
    POLARSSL_PK_ECKEY_DH,
    POLARSSL_PK_ECDSA,
    POLARSSL_PK_RSA_ALT,
    POLARSSL_PK_RSASSA_PSS,
} pk_type_t;
 
typedef struct
{
    md_type_t mgf1_hash_id;
    int expected_salt_len;
 
} pk_rsassa_pss_options;
 
typedef enum
{
    POLARSSL_PK_DEBUG_NONE = 0,
    POLARSSL_PK_DEBUG_MPI,
    POLARSSL_PK_DEBUG_ECP,
} pk_debug_type;
 
typedef struct
{
    pk_debug_type type;
    const char *name;
    void *value;
} pk_debug_item;
 
#define POLARSSL_PK_DEBUG_MAX_ITEMS 3
 
typedef struct
{
    pk_type_t type;
 
    const char *name;
 
    size_t (*get_size)( const void * );
 
    int (*can_do)( pk_type_t type );
 
    int (*verify_func)( void *ctx, md_type_t md_alg,
                        const unsigned char *hash, size_t hash_len,
                        const unsigned char *sig, size_t sig_len );
 
    int (*sign_func)( void *ctx, md_type_t md_alg,
                      const unsigned char *hash, size_t hash_len,
                      unsigned char *sig, size_t *sig_len,
                      int (*f_rng)(void *, unsigned char *, size_t),
                      void *p_rng );
 
    int (*decrypt_func)( void *ctx, const unsigned char *input, size_t ilen,
                         unsigned char *output, size_t *olen, size_t osize,
                         int (*f_rng)(void *, unsigned char *, size_t),
                         void *p_rng );
 
    int (*encrypt_func)( void *ctx, const unsigned char *input, size_t ilen,
                         unsigned char *output, size_t *olen, size_t osize,
                         int (*f_rng)(void *, unsigned char *, size_t),
                         void *p_rng );
 
    void * (*ctx_alloc_func)( void );
 
    void (*ctx_free_func)( void *ctx );
 
    void (*debug_func)( const void *ctx, pk_debug_item *items );
 
} pk_info_t;
 
typedef struct
{
    const pk_info_t *   pk_info;    
    void *              pk_ctx;     
} pk_context;
 
typedef int (*pk_rsa_alt_decrypt_func)( void *ctx, int mode, size_t *olen,
                    const unsigned char *input, unsigned char *output,
                    size_t output_max_len );
typedef int (*pk_rsa_alt_sign_func)( void *ctx,
                    int (*f_rng)(void *, unsigned char *, size_t), void *p_rng,
                    int mode, md_type_t md_alg, unsigned int hashlen,
                    const unsigned char *hash, unsigned char *sig );
typedef size_t (*pk_rsa_alt_key_len_func)( void *ctx );
 
const pk_info_t *pk_info_from_type( pk_type_t pk_type );
 
void pk_init( pk_context *ctx );
 
void pk_free( pk_context *ctx );
 
int pk_init_ctx( pk_context *ctx, const pk_info_t *info );
 
int pk_init_ctx_rsa_alt( pk_context *ctx, void * key,
                         pk_rsa_alt_decrypt_func decrypt_func,
                         pk_rsa_alt_sign_func sign_func,
                         pk_rsa_alt_key_len_func key_len_func );
 
size_t pk_get_size( const pk_context *ctx );
 
static inline size_t pk_get_len( const pk_context *ctx )
{
    return( ( pk_get_size( ctx ) + 7 ) / 8 );
}
 
int pk_can_do( pk_context *ctx, pk_type_t type );
 
int pk_verify( pk_context *ctx, md_type_t md_alg,
               const unsigned char *hash, size_t hash_len,
               const unsigned char *sig, size_t sig_len );
 
int pk_verify_ext( pk_type_t type, const void *options,
                   pk_context *ctx, md_type_t md_alg,
                   const unsigned char *hash, size_t hash_len,
                   const unsigned char *sig, size_t sig_len );
 
int pk_sign( pk_context *ctx, md_type_t md_alg,
             const unsigned char *hash, size_t hash_len,
             unsigned char *sig, size_t *sig_len,
             int (*f_rng)(void *, unsigned char *, size_t), void *p_rng );
 
int pk_decrypt( pk_context *ctx,
                const unsigned char *input, size_t ilen,
                unsigned char *output, size_t *olen, size_t osize,
                int (*f_rng)(void *, unsigned char *, size_t), void *p_rng );
 
int pk_encrypt( pk_context *ctx,
                const unsigned char *input, size_t ilen,
                unsigned char *output, size_t *olen, size_t osize,
                int (*f_rng)(void *, unsigned char *, size_t), void *p_rng );
 
int pk_debug( const pk_context *ctx, pk_debug_item *items );
 
const char * pk_get_name( const pk_context *ctx );
 
pk_type_t pk_get_type( const pk_context *ctx );
 
#if defined(POLARSSL_PK_PARSE_C)
int pk_parse_key( pk_context *ctx,
                  const unsigned char *key, size_t keylen,
                  const unsigned char *pwd, size_t pwdlen );
 
int pk_parse_public_key( pk_context *ctx,
                         const unsigned char *key, size_t keylen );
 
#if defined(POLARSSL_FS_IO)
int pk_parse_keyfile( pk_context *ctx,
                      const char *path, const char *password );
 
int pk_parse_public_keyfile( pk_context *ctx, const char *path );
#endif /* POLARSSL_FS_IO */
#endif /* POLARSSL_PK_PARSE_C */
 
#if defined(POLARSSL_PK_WRITE_C)
int pk_write_key_der( pk_context *ctx, unsigned char *buf, size_t size );
 
int pk_write_pubkey_der( pk_context *ctx, unsigned char *buf, size_t size );
 
#if defined(POLARSSL_PEM_WRITE_C)
int pk_write_pubkey_pem( pk_context *ctx, unsigned char *buf, size_t size );
 
int pk_write_key_pem( pk_context *ctx, unsigned char *buf, size_t size );
#endif /* POLARSSL_PEM_WRITE_C */
#endif /* POLARSSL_PK_WRITE_C */
 
/*
 * WARNING: Low-level functions. You probably do not want to use these unless
 *          you are certain you do ;)
 */
 
#if defined(POLARSSL_PK_PARSE_C)
int pk_parse_subpubkey( unsigned char **p, const unsigned char *end,
                        pk_context *pk );
#endif /* POLARSSL_PK_PARSE_C */
 
#if defined(POLARSSL_PK_WRITE_C)
int pk_write_pubkey( unsigned char **p, unsigned char *start,
                     const pk_context *key );
#endif /* POLARSSL_PK_WRITE_C */
 
#ifdef __cplusplus
}
#endif
 
#endif /* POLARSSL_PK_H */