lib/silccrypt/silcpkcs.h

   1 /*
   2
   3   silcpkcs.h
   4
   5   Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
   6
   7   Copyright (C) 1997 - 2001 Pekka Riikonen
   8
   9   This program is free software; you can redistribute it and/or modify
  10   it under the terms of the GNU General Public License as published by
  11   the Free Software Foundation; either version 2 of the License, or
  12   (at your option) any later version.
  13
  14   This program is distributed in the hope that it will be useful,
  15   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17   GNU General Public License for more details.
  18
  19 */
  20
  21 #ifndef SILCPKCS_H
  22 #define SILCPKCS_H
  23
  24 /* The default SILC PKCS (Public Key Cryptosystem) object to represent
  25    any PKCS in SILC. */
  26 typedef struct SilcPKCSObjectStruct {
  27   char *name;
  28   void *data_context;
  29
  30   int (*init)(void *, uint32, SilcRng);
  31   void (*clear_keys)(void *);
  32   unsigned char *(*get_public_key)(void *, uint32 *);
  33   unsigned char *(*get_private_key)(void *, uint32 *);
  34   int (*set_public_key)(void *, unsigned char *, uint32);
  35   int (*set_private_key)(void *, unsigned char *, uint32);
  36   uint32 (*context_len)();
  37   uint32 (*data_context_len)();
  38   int (*set_arg)(void *, void *, int, SilcInt);
  39   int (*encrypt)(void *, unsigned char *, uint32,
  40                  unsigned char *, uint32 *);
  41   int (*decrypt)(void *, unsigned char *, uint32,
  42                  unsigned char *, uint32 *);
  43   int (*sign)(void *, unsigned char *, uint32,
  44               unsigned char *, uint32 *);
  45   int (*verify)(void *, unsigned char *, uint32,
  46                 unsigned char *, uint32);
  47 } SilcPKCSObject;
  48
  49 /* The main SILC PKCS structure. Use SilcPKCS instead of SilcPKCSStruct.
  50    Also remember that SilcPKCS is a pointer. */
  51 typedef struct SilcPKCSStruct {
  52   void *context;
  53   SilcPKCSObject *pkcs;
  54   uint32 key_len;
  55
  56   uint32 (*get_key_len)(struct SilcPKCSStruct *);
  57 } *SilcPKCS;
  58
  59 /* List of all PKCS in SILC. */
  60 extern SilcPKCSObject silc_pkcs_list[];
  61
  62 /* SILC style public key object. Public key is read from file to this
  63    object. Public keys received from network must be in this format as
  64    well. */
  65 typedef struct {
  66   uint32 len;
  67   char *name;
  68   char *identifier;
  69   unsigned char *pk;
  70   uint32 pk_len;
  71 } *SilcPublicKey;
  72
  73 /* SILC style private key object. Private key is read from file to this
  74    object. */
  75 typedef struct {
  76   char *name;
  77   unsigned char *prv;
  78   uint32 prv_len;
  79 } *SilcPrivateKey;
  80
  81 /* Public and private key file headers */
  82 #define SILC_PKCS_PUBLIC_KEYFILE_BEGIN "-----BEGIN SILC PUBLIC KEY-----\n"
  83 #define SILC_PKCS_PUBLIC_KEYFILE_END "\n-----END SILC PUBLIC KEY-----\n"
  84 #define SILC_PKCS_PRIVATE_KEYFILE_BEGIN "-----BEGIN SILC PRIVATE KEY-----\n"
  85 #define SILC_PKCS_PRIVATE_KEYFILE_END "\n-----END SILC PRIVATE KEY-----\n"
  86
  87 /* Public and private key file encoding types */
  88 #define SILC_PKCS_FILE_BIN 0
  89 #define SILC_PKCS_FILE_PEM 1
  90
  91 /* Macros */
  92
  93 /* Macros used to implement the SILC PKCS API */
  94
  95 /* XXX: This needs slight redesigning. These needs to be made even
  96    more generic. I don't like that the actual prime generation is done
  97    in PKCS_API_INIT. The primes used in key generation should be sent
  98    as argument to the init function. By doing this we would achieve
  99    that PKCS could be used as SIM's. The only requirement would be
 100    that they are compiled against GMP (well, actually even that would
 101    not be a requirement, but the most generic case anyway). The new init
 102    would look something like this:
 103
 104    #define SILC_PKCS_API_INIT(pkcs) \
 105    inline int silc_##pkcs##_init(void *context, uint32 keylen, \
 106                                  void *p1, void *p2)
 107
 108    Now we wouldn't have to send the SilcRng object since the primes are
 109    provided as arguments. To send them as void * they could actually be
 110    used as in anyway for real (MP_INT (SilcInt) or even something else
 111    (the pointer could be kludged to be something else in the module))
 112    (Plus, the SilcRng object management in prime generation would be
 113    simpler and better what it is now (in silcprimegen.c, that is)).
 114 */
 115
 116 #define SILC_PKCS_API_INIT(pkcs) \
 117 int silc_##pkcs##_init(void *context, uint32 keylen, \
 118                        SilcRng rng)
 119 #define SILC_PKCS_API_CLEAR_KEYS(pkcs) \
 120 void silc_##pkcs##_clear_keys(void *context)
 121 #define SILC_PKCS_API_GET_PUBLIC_KEY(pkcs) \
 122 unsigned char *silc_##pkcs##_get_public_key(void *context, \
 123                                             uint32 *ret_len)
 124 #define SILC_PKCS_API_GET_PRIVATE_KEY(pkcs) \
 125 unsigned char *silc_##pkcs##_get_private_key(void *context, \
 126                                              uint32 *ret_len)
 127 #define SILC_PKCS_API_SET_PUBLIC_KEY(pkcs) \
 128 int silc_##pkcs##_set_public_key(void *context, unsigned char *key_data, \
 129                                  uint32 key_len)
 130 #define SILC_PKCS_API_SET_PRIVATE_KEY(pkcs) \
 131 int silc_##pkcs##_set_private_key(void *context, unsigned char *key_data, \
 132                                   uint32 key_len)
 133 #define SILC_PKCS_API_CONTEXT_LEN(pkcs) \
 134 uint32 silc_##pkcs##_context_len()
 135 #define SILC_PKCS_API_DATA_CONTEXT_LEN(pkcs) \
 136 uint32 silc_##pkcs##_data_context_len()
 137 #define SILC_PKCS_API_SET_ARG(pkcs) \
 138 int silc_##pkcs##_set_arg(void *context, \
 139                           void *data_context, \
 140                           int argnum, \
 141                           SilcInt val)
 142 #define SILC_PKCS_API_ENCRYPT(pkcs) \
 143 int silc_##pkcs##_encrypt(void *context, \
 144                           unsigned char *src, \
 145                           uint32 src_len, \
 146                           unsigned char *dst, \
 147                           uint32 *dst_len)
 148 #define SILC_PKCS_API_DECRYPT(pkcs) \
 149 int silc_##pkcs##_decrypt(void *context, \
 150                           unsigned char *src, \
 151                           uint32 src_len, \
 152                           unsigned char *dst, \
 153                           uint32 *dst_len)
 154 #define SILC_PKCS_API_SIGN(pkcs) \
 155 int silc_##pkcs##_sign(void *context, \
 156                        unsigned char *src, \
 157                        uint32 src_len, \
 158                        unsigned char *dst, \
 159                        uint32 *dst_len)
 160 #define SILC_PKCS_API_VERIFY(pkcs) \
 161 int silc_##pkcs##_verify(void *context, \
 162                          unsigned char *signature, \
 163                          uint32 signature_len, \
 164                          unsigned char *data, \
 165                          uint32 data_len)
 166
 167 /* Prototypes */
 168 int silc_pkcs_alloc(const unsigned char *name, SilcPKCS *new_pkcs);
 169 void silc_pkcs_free(SilcPKCS pkcs);
 170 int silc_pkcs_is_supported(const unsigned char *name);
 171 char *silc_pkcs_get_supported();
 172 uint32 silc_pkcs_get_key_len(SilcPKCS self);
 173 unsigned char *silc_pkcs_get_public_key(SilcPKCS pkcs, uint32 *len);
 174 unsigned char *silc_pkcs_get_private_key(SilcPKCS pkcs, uint32 *len);
 175 int silc_pkcs_public_key_set(SilcPKCS pkcs, SilcPublicKey public_key);
 176 int silc_pkcs_public_key_data_set(SilcPKCS pkcs, unsigned char *pk,
 177                                   uint32 pk_len);
 178 int silc_pkcs_private_key_set(SilcPKCS pkcs, SilcPrivateKey private_key);
 179 int silc_pkcs_private_key_data_set(SilcPKCS pkcs, unsigned char *prv,
 180                                    uint32 prv_len);
 181 int silc_pkcs_encrypt(SilcPKCS pkcs, unsigned char *src, uint32 src_len,
 182                       unsigned char *dst, uint32 *dst_len);
 183 int silc_pkcs_decrypt(SilcPKCS pkcs, unsigned char *src, uint32 src_len,
 184                       unsigned char *dst, uint32 *dst_len);
 185 int silc_pkcs_sign(SilcPKCS pkcs, unsigned char *src, uint32 src_len,
 186                    unsigned char *dst, uint32 *dst_len);
 187 int silc_pkcs_verify(SilcPKCS pkcs, unsigned char *signature,
 188                      uint32 signature_len, unsigned char *data,
 189                      uint32 data_len);
 190 int silc_pkcs_sign_with_hash(SilcPKCS pkcs, SilcHash hash,
 191                              unsigned char *src, uint32 src_len,
 192                              unsigned char *dst, uint32 *dst_len);
 193 int silc_pkcs_verify_with_hash(SilcPKCS pkcs, SilcHash hash,
 194                                unsigned char *signature,
 195                                uint32 signature_len,
 196                                unsigned char *data,
 197                                uint32 data_len);
 198 char *silc_pkcs_encode_identifier(char *username, char *host, char *realname,
 199                                   char *email, char *org, char *country);
 200 SilcPublicKey silc_pkcs_public_key_alloc(char *name, char *identifier,
 201                                          unsigned char *pk,
 202                                          uint32 pk_len);
 203 void silc_pkcs_public_key_free(SilcPublicKey public_key);
 204 SilcPrivateKey silc_pkcs_private_key_alloc(char *name, unsigned char *prv,
 205                                            uint32 prv_len);
 206 void silc_pkcs_private_key_free(SilcPrivateKey private_key);
 207 unsigned char *
 208 silc_pkcs_public_key_encode(SilcPublicKey public_key, uint32 *len);
 209 unsigned char *
 210 silc_pkcs_public_key_data_encode(unsigned char *pk, uint32 pk_len,
 211                                  char *pkcs, char *identifier,
 212                                  uint32 *len);
 213 int silc_pkcs_public_key_decode(unsigned char *data, uint32 data_len,
 214                                 SilcPublicKey *public_key);
 215 unsigned char *
 216 silc_pkcs_private_key_encode(SilcPrivateKey private_key, uint32 *len);
 217 unsigned char *
 218 silc_pkcs_private_key_data_encode(unsigned char *prv, uint32 prv_len,
 219                                   char *pkcs, uint32 *len);
 220 int silc_pkcs_private_key_decode(unsigned char *data, uint32 data_len,
 221                                  SilcPrivateKey *private_key);
 222 int silc_pkcs_save_public_key(char *filename, SilcPublicKey public_key,
 223                               uint32 encoding);
 224 int silc_pkcs_save_public_key_data(char *filename, unsigned char *data,
 225                                    uint32 data_len,
 226                                    uint32 encoding);
 227 int silc_pkcs_save_private_key(char *filename, SilcPrivateKey private_key,
 228                                unsigned char *passphrase,
 229                                uint32 encoding);
 230 int silc_pkcs_save_private_key_data(char *filename, unsigned char *data,
 231                                     uint32 data_len,
 232                                     unsigned char *passphrase,
 233                                     uint32 encoding);
 234 int silc_pkcs_load_public_key(char *filename, SilcPublicKey *public_key,
 235                               uint32 encoding);
 236 int silc_pkcs_load_private_key(char *filename, SilcPrivateKey *private_key,
 237                                uint32 encoding);
 238
 239 #endif