lib/silccrypt/silcpkcs_i.h

   1 /*
   2
   3   silcpkcs_i.h
   4
   5   Author: Pekka Riikonen <priikone@silcnet.org>
   6
   7   Copyright (C) 1997 - 2007 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; version 2 of the License.
  12
  13   This program is distributed in the hope that it will be useful,
  14   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16   GNU General Public License for more details.
  17
  18 */
  19
  20 #ifndef SILCPKCS_I_H
  21 #define SILCPKCS_I_H
  22
  23 #ifndef SILCPKCS_H
  24 #error "Do not include this header directly"
  25 #endif
  26
  27 /* Macros for defining the PKCS APIs.  Use these when you need to declare
  28    PKCS API functions. */
  29
  30 #define SILC_PKCS_ALG_GENERATE_KEY(name)                        \
  31   SilcBool name(const struct SilcPKCSAlgorithmStruct *pkcs,     \
  32                 SilcUInt32 keylen, SilcRng rng,                 \
  33                 void **ret_public_key, void **ret_private_key)
  34
  35 #define SILC_PKCS_ALG_IMPORT_PUBLIC_KEY(name)                           \
  36   int name(const struct SilcPKCSAlgorithmStruct *pkcs,                  \
  37            void *key, SilcUInt32 key_len,                       \
  38            void **ret_public_key)
  39
  40 #define SILC_PKCS_ALG_EXPORT_PUBLIC_KEY(name)                           \
  41   unsigned char *name(const struct SilcPKCSAlgorithmStruct *pkcs,       \
  42                       SilcStack stack,                                  \
  43                       void *public_key,                                 \
  44                       SilcUInt32 *ret_len)
  45
  46 #define SILC_PKCS_ALG_PUBLIC_KEY_BITLEN(name)                           \
  47   SilcUInt32 name(const struct SilcPKCSAlgorithmStruct *pkcs,           \
  48                   void *public_key)
  49
  50 #define SILC_PKCS_ALG_PUBLIC_KEY_COPY(name)                     \
  51   void *name(const struct SilcPKCSAlgorithmStruct *pkcs,        \
  52              void *public_key)
  53
  54 #define SILC_PKCS_ALG_PUBLIC_KEY_COMPARE(name)                          \
  55   SilcBool name(const struct SilcPKCSAlgorithmStruct *pkcs,             \
  56                 void *key1, void *key2)
  57
  58 #define SILC_PKCS_ALG_PUBLIC_KEY_FREE(name)                             \
  59   void name(const struct SilcPKCSAlgorithmStruct *pkcs, void *public_key)
  60
  61 #define SILC_PKCS_ALG_IMPORT_PRIVATE_KEY(name)                          \
  62   int name(const struct SilcPKCSAlgorithmStruct *pkcs,                  \
  63            void *key, SilcUInt32 key_len,                               \
  64            void **ret_private_key)
  65
  66 #define SILC_PKCS_ALG_EXPORT_PRIVATE_KEY(name)                          \
  67   unsigned char *name(const struct SilcPKCSAlgorithmStruct *pkcs,       \
  68                       SilcStack stack, void *private_key,               \
  69                       SilcUInt32 *ret_len)
  70
  71 #define SILC_PKCS_ALG_PRIVATE_KEY_BITLEN(name)                  \
  72   SilcUInt32 name(const struct SilcPKCSAlgorithmStruct *pkcs,   \
  73                   void *private_key)
  74
  75 #define SILC_PKCS_ALG_PRIVATE_KEY_FREE(name)            \
  76   void name(const struct SilcPKCSAlgorithmStruct *pkcs, \
  77             void *private_key)
  78
  79 #define SILC_PKCS_ALG_ENCRYPT(name)                                     \
  80   SilcAsyncOperation name(const struct SilcPKCSAlgorithmStruct *pkcs,   \
  81                           void *public_key,                             \
  82                           unsigned char *src,                           \
  83                           SilcUInt32 src_len,                           \
  84                           SilcRng rng,                                  \
  85                           SilcPKCSEncryptCb encrypt_cb,                 \
  86                           void *context)
  87
  88 #define SILC_PKCS_ALG_DECRYPT(name)                                     \
  89   SilcAsyncOperation name(const struct SilcPKCSAlgorithmStruct *pkcs,   \
  90                           void *private_key,                            \
  91                           unsigned char *src,                           \
  92                           SilcUInt32 src_len,                           \
  93                           SilcPKCSDecryptCb decrypt_cb,                 \
  94                           void *context)
  95
  96 #define SILC_PKCS_ALG_SIGN(name)                                        \
  97   SilcAsyncOperation name(const struct SilcPKCSAlgorithmStruct *pkcs,   \
  98                           void *private_key,                            \
  99                           unsigned char *src,                           \
 100                           SilcUInt32 src_len,                           \
 101                           SilcBool compute_hash,                        \
 102                           SilcHash hash,                                \
 103                           SilcRng rng,                                  \
 104                           SilcPKCSSignCb sign_cb,                       \
 105                           void *context)
 106
 107 #define SILC_PKCS_ALG_VERIFY(name)                                      \
 108   SilcAsyncOperation name(const struct SilcPKCSAlgorithmStruct *pkcs,   \
 109                           void *public_key,                             \
 110                           unsigned char *signature,                     \
 111                           SilcUInt32 signature_len,                     \
 112                           unsigned char *data,                          \
 113                           SilcUInt32 data_len,                          \
 114                           SilcHash hash,                                \
 115                           SilcRng rng,                                  \
 116                           SilcPKCSVerifyCb verify_cb,                   \
 117                           void *context)
 118
 119 /* The PKCS Algorithm object to represent any PKCS algorithm.  This context
 120    implements the PKCS algorithm, such as RSA, DSA, etc. */
 121 struct SilcPKCSAlgorithmStruct {
 122   /* Algorithm name and scheme */
 123   char *name;                   /* Eg. rsa, dsa, etc. */
 124   char *scheme;                 /* Eg. pkcs1, openpgp, etc. */
 125
 126   /* Supported hash functions, comma separated list */
 127   char *hash;
 128
 129   /* Generate new key pair. Returns PKCS algorithm specific public key
 130      and private key contexts. */
 131   SILC_PKCS_ALG_GENERATE_KEY((*generate_key));
 132
 133   /* Public key routines. */
 134
 135   /* Import/create new public key.  Returns the length of the data that was
 136      imported from `key' or 0 on error.  Returns the PKCS algorithm specific
 137      public key to `ret_public_key'. */
 138   SILC_PKCS_ALG_IMPORT_PUBLIC_KEY((*import_public_key));
 139
 140   /* Export/encode public key.  Returns the encoded public key buffer that
 141      the caller must free. */
 142   SILC_PKCS_ALG_EXPORT_PUBLIC_KEY((*export_public_key));
 143
 144   /* Returns the bit length of public key */
 145   SILC_PKCS_ALG_PUBLIC_KEY_BITLEN((*public_key_bitlen));
 146
 147   /* Duplicated public key */
 148   SILC_PKCS_ALG_PUBLIC_KEY_COPY((*public_key_copy));
 149
 150   /* Compares two public keys.  Returns TRUE if they are identical. */
 151   SILC_PKCS_ALG_PUBLIC_KEY_COMPARE((*public_key_compare));
 152
 153   /* Free public key */
 154   SILC_PKCS_ALG_PUBLIC_KEY_FREE((*public_key_free));
 155
 156   /* Private key routines. */
 157
 158   /* Import/create new private key.  Returns the length of the data that was
 159      imported from `key' or 0 on error.  Returns the PKCS algorithm specific
 160      private key to `ret_private_key'. */
 161   SILC_PKCS_ALG_IMPORT_PRIVATE_KEY((*import_private_key));
 162
 163   /* Export/encode private key.  Returns the encoded private key buffer that
 164      the caller must free. */
 165   SILC_PKCS_ALG_EXPORT_PRIVATE_KEY((*export_private_key));
 166
 167   /* Returns the bi length of private key */
 168   SILC_PKCS_ALG_PRIVATE_KEY_BITLEN((*private_key_bitlen));
 169
 170   /* Free private key */
 171   SILC_PKCS_ALG_PRIVATE_KEY_FREE((*private_key_free));
 172
 173   /* Encrypt and decrypt operations */
 174   SILC_PKCS_ALG_ENCRYPT((*encrypt));
 175   SILC_PKCS_ALG_DECRYPT((*decrypt));
 176
 177   /* Signature and verification operations */
 178   SILC_PKCS_ALG_SIGN((*sign));
 179   SILC_PKCS_ALG_VERIFY((*verify));
 180 };
 181
 182 /* Macros for defining the PKCS APIs.  Use these when you need to declare
 183    PKCS API functions. */
 184
 185 #define SILC_PKCS_GET_ALGORITHM(name)                                   \
 186   const SilcPKCSAlgorithm *name(const struct SilcPKCSObjectStruct *pkcs, \
 187                                 void *public_key)
 188
 189 #define SILC_PKCS_IMPORT_PUBLIC_KEY_FILE(name)                          \
 190   SilcBool name(const struct SilcPKCSObjectStruct *pkcs,                \
 191                 unsigned char *filedata, SilcUInt32 filedata_len,       \
 192                 SilcPKCSFileEncoding encoding, void **ret_public_key,   \
 193                 const struct SilcPKCSAlgorithmStruct **ret_alg)
 194
 195 #define SILC_PKCS_IMPORT_PUBLIC_KEY(name)                               \
 196   int name(const struct SilcPKCSObjectStruct *pkcs,                     \
 197            const struct SilcPKCSAlgorithmStruct *alg,                   \
 198            void *key, SilcUInt32 key_len, void **ret_public_key,        \
 199            const struct SilcPKCSAlgorithmStruct **ret_alg)
 200
 201 #define SILC_PKCS_EXPORT_PUBLIC_KEY_FILE(name)                  \
 202   unsigned char *name(const struct SilcPKCSObjectStruct *pkcs,  \
 203                       SilcStack stack, void *public_key,        \
 204                       SilcPKCSFileEncoding encoding,            \
 205                       SilcUInt32 *ret_len)
 206
 207 #define SILC_PKCS_EXPORT_PUBLIC_KEY(name)                               \
 208   unsigned char *name(const struct SilcPKCSObjectStruct *pkcs,          \
 209                       SilcStack stack, void *public_key, SilcUInt32 *ret_len)
 210
 211 #define SILC_PKCS_PUBLIC_KEY_BITLEN(name)                       \
 212   SilcUInt32 name(const struct SilcPKCSObjectStruct *pkcs,      \
 213                   void *public_key)
 214
 215 #define SILC_PKCS_PUBLIC_KEY_COPY(name)                                 \
 216   void *name(const struct SilcPKCSObjectStruct *pkcs, void *public_key)
 217
 218 #define SILC_PKCS_PUBLIC_KEY_COMPARE(name)                      \
 219   SilcBool name(const struct SilcPKCSObjectStruct *pkcs,        \
 220                 void *key1, void *key2)
 221
 222 #define SILC_PKCS_PUBLIC_KEY_FREE(name)                                 \
 223   void name(const struct SilcPKCSObjectStruct *pkcs, void *public_key)
 224
 225 #define SILC_PKCS_IMPORT_PRIVATE_KEY_FILE(name)                         \
 226   SilcBool name(const struct SilcPKCSObjectStruct *pkcs,                \
 227                 unsigned char *filedata, SilcUInt32 filedata_len,       \
 228                 const char *passphrase, SilcUInt32 passphrase_len,      \
 229                 SilcPKCSFileEncoding encoding, void **ret_private_key,  \
 230                 const struct SilcPKCSAlgorithmStruct **ret_alg)
 231
 232 #define SILC_PKCS_IMPORT_PRIVATE_KEY(name)                              \
 233   int name(const struct SilcPKCSObjectStruct *pkcs,                     \
 234            const struct SilcPKCSAlgorithmStruct *alg,                   \
 235            const char *passphrase, SilcUInt32 passphrase_len,           \
 236            void *key, SilcUInt32 key_len, void **ret_private_key,       \
 237            const struct SilcPKCSAlgorithmStruct **ret_alg)
 238
 239 #define SILC_PKCS_EXPORT_PRIVATE_KEY_FILE(name)                         \
 240   unsigned char *name(const struct SilcPKCSObjectStruct *pkcs,          \
 241                       SilcStack stack, void *private_key,               \
 242                       const char *passphrase, SilcUInt32 passphrase_len, \
 243                       SilcPKCSFileEncoding encoding, SilcRng rng,       \
 244                       SilcUInt32 *ret_len)
 245
 246 #define SILC_PKCS_EXPORT_PRIVATE_KEY(name)                              \
 247   unsigned char *name(const struct SilcPKCSObjectStruct *pkcs,          \
 248                       SilcStack stack, void *private_key, SilcUInt32 *ret_len)
 249
 250 #define SILC_PKCS_PRIVATE_KEY_BITLEN(name)                      \
 251   SilcUInt32 name(const struct SilcPKCSObjectStruct *pkcs, void *private_key)
 252
 253 #define SILC_PKCS_PRIVATE_KEY_FREE(name)                                \
 254   void name(const struct SilcPKCSObjectStruct *pkcs, void *private_key)
 255
 256 #define SILC_PKCS_ENCRYPT(name)                                         \
 257   SilcAsyncOperation name(const struct SilcPKCSObjectStruct *pkcs,      \
 258                           void *public_key,                             \
 259                           unsigned char *src,                           \
 260                           SilcUInt32 src_len,                           \
 261                           SilcRng rng,                                  \
 262                           SilcPKCSEncryptCb encrypt_cb,                 \
 263                           void *context)
 264
 265 #define SILC_PKCS_DECRYPT(name)                                         \
 266   SilcAsyncOperation name(const struct SilcPKCSObjectStruct *pkcs,      \
 267                           void *private_key,                            \
 268                           unsigned char *src,                           \
 269                           SilcUInt32 src_len,                           \
 270                           SilcPKCSDecryptCb decrypt_cb,                 \
 271                           void *context)
 272
 273 #define SILC_PKCS_SIGN(name)                                            \
 274   SilcAsyncOperation name(const struct SilcPKCSObjectStruct *pkcs,      \
 275                           void *private_key,                            \
 276                           unsigned char *src,                           \
 277                           SilcUInt32 src_len,                           \
 278                           SilcBool compute_hash,                        \
 279                           SilcHash hash,                                \
 280                           SilcRng rng,                                  \
 281                           SilcPKCSSignCb sign_cb,                       \
 282                           void *context)
 283
 284 #define SILC_PKCS_VERIFY(name)                                          \
 285   SilcAsyncOperation name(const struct SilcPKCSObjectStruct *pkcs,      \
 286                           void *public_key,                             \
 287                           unsigned char *signature,                     \
 288                           SilcUInt32 signature_len,                     \
 289                           unsigned char *data,                          \
 290                           SilcUInt32 data_len,                          \
 291                           SilcHash hash,                                \
 292                           SilcRng rng,                                  \
 293                           SilcPKCSVerifyCb verify_cb,                   \
 294                           void *context)
 295
 296 /* The PKCS (Public Key Cryptosystem) object to represent any PKCS.  This
 297    context implements the PKCS, such as SILC public keys, X.509 certificates,
 298    OpenPGP certificates, etc. under a common API. */
 299 struct SilcPKCSObjectStruct {
 300   /* PKCS type */
 301   SilcPKCSType type;
 302
 303   /* Public key routines */
 304
 305   /* Returns PKCS algorithm context from public key */
 306   SILC_PKCS_GET_ALGORITHM((*get_algorithm));
 307
 308   /* Imports from public key file */
 309   SILC_PKCS_IMPORT_PUBLIC_KEY_FILE((*import_public_key_file));
 310
 311   /* Imports from public key binary data.  Returns the amount of bytes
 312      imported from `key' or 0 on error. */
 313   SILC_PKCS_IMPORT_PUBLIC_KEY((*import_public_key));
 314
 315   /* Exports public key to file */
 316   SILC_PKCS_EXPORT_PUBLIC_KEY_FILE((*export_public_key_file));
 317
 318   /* Export public key as binary data */
 319   SILC_PKCS_EXPORT_PUBLIC_KEY((*export_public_key));
 320
 321   /* Returns key length in bits */
 322   SILC_PKCS_PUBLIC_KEY_BITLEN((*public_key_bitlen));
 323
 324   /* Copy public key */
 325   SILC_PKCS_PUBLIC_KEY_COPY((*public_key_copy));
 326
 327   /* Compares public keys */
 328   SILC_PKCS_PUBLIC_KEY_COMPARE((*public_key_compare));
 329
 330   /* Free public key */
 331   SILC_PKCS_PUBLIC_KEY_FREE((*public_key_free));
 332
 333   /* Private key routines */
 334
 335   /* Imports from private key file */
 336   SILC_PKCS_IMPORT_PRIVATE_KEY_FILE((*import_private_key_file));
 337
 338   /* Imports from private key binary data.  Returns the amount of bytes
 339      imported from `key' or 0 on error. */
 340   SILC_PKCS_IMPORT_PRIVATE_KEY((*import_private_key));
 341
 342   /* Exports private key to file */
 343   SILC_PKCS_EXPORT_PRIVATE_KEY_FILE((*export_private_key_file));
 344
 345   /* Export private key as binary data */
 346   SILC_PKCS_EXPORT_PRIVATE_KEY((*export_private_key));
 347
 348   /* Returns key length in bits */
 349   SILC_PKCS_PRIVATE_KEY_BITLEN((*private_key_bitlen));
 350
 351   /* Free private key */
 352   SILC_PKCS_PRIVATE_KEY_FREE((*private_key_free));
 353
 354   /* Encrypt and decrypt operations */
 355   SILC_PKCS_ENCRYPT((*encrypt));
 356   SILC_PKCS_DECRYPT((*decrypt));
 357
 358   /* Signature and verification operations */
 359   SILC_PKCS_SIGN((*sign));
 360   SILC_PKCS_VERIFY((*verify));
 361 };
 362
 363 /* Backwards support for PKCS API */
 364
 365 #define silc_pkcs_get_context silc_pkcs_public_key_get_pkcs
 366
 367 #endif /* SILCPKCS_I_H */