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            void *key, SilcUInt32 key_len, void **ret_private_key,       \
 236            const struct SilcPKCSAlgorithmStruct **ret_alg)
 237
 238 #define SILC_PKCS_EXPORT_PRIVATE_KEY_FILE(name)                         \
 239   unsigned char *name(const struct SilcPKCSObjectStruct *pkcs,          \
 240                       SilcStack stack, void *private_key,               \
 241                       const char *passphrase, SilcUInt32 passphrase_len, \
 242                       SilcPKCSFileEncoding encoding, SilcRng rng,       \
 243                       SilcUInt32 *ret_len)
 244
 245 #define SILC_PKCS_EXPORT_PRIVATE_KEY(name)                              \
 246   unsigned char *name(const struct SilcPKCSObjectStruct *pkcs,          \
 247                       SilcStack stack, void *private_key, SilcUInt32 *ret_len)
 248
 249 #define SILC_PKCS_PRIVATE_KEY_BITLEN(name)                      \
 250   SilcUInt32 name(const struct SilcPKCSObjectStruct *pkcs, void *private_key)
 251
 252 #define SILC_PKCS_PRIVATE_KEY_FREE(name)                                \
 253   void name(const struct SilcPKCSObjectStruct *pkcs, void *private_key)
 254
 255 #define SILC_PKCS_ENCRYPT(name)                                         \
 256   SilcAsyncOperation name(const struct SilcPKCSObjectStruct *pkcs,      \
 257                           void *public_key,                             \
 258                           unsigned char *src,                           \
 259                           SilcUInt32 src_len,                           \
 260                           SilcRng rng,                                  \
 261                           SilcPKCSEncryptCb encrypt_cb,                 \
 262                           void *context)
 263
 264 #define SILC_PKCS_DECRYPT(name)                                         \
 265   SilcAsyncOperation name(const struct SilcPKCSObjectStruct *pkcs,      \
 266                           void *private_key,                            \
 267                           unsigned char *src,                           \
 268                           SilcUInt32 src_len,                           \
 269                           SilcPKCSDecryptCb decrypt_cb,                 \
 270                           void *context)
 271
 272 #define SILC_PKCS_SIGN(name)                                            \
 273   SilcAsyncOperation name(const struct SilcPKCSObjectStruct *pkcs,      \
 274                           void *private_key,                            \
 275                           unsigned char *src,                           \
 276                           SilcUInt32 src_len,                           \
 277                           SilcBool compute_hash,                        \
 278                           SilcHash hash,                                \
 279                           SilcRng rng,                                  \
 280                           SilcPKCSSignCb sign_cb,                       \
 281                           void *context)
 282
 283 #define SILC_PKCS_VERIFY(name)                                          \
 284   SilcAsyncOperation name(const struct SilcPKCSObjectStruct *pkcs,      \
 285                           void *public_key,                             \
 286                           unsigned char *signature,                     \
 287                           SilcUInt32 signature_len,                     \
 288                           unsigned char *data,                          \
 289                           SilcUInt32 data_len,                          \
 290                           SilcHash hash,                                \
 291                           SilcRng rng,                                  \
 292                           SilcPKCSVerifyCb verify_cb,                   \
 293                           void *context)
 294
 295 /* The PKCS (Public Key Cryptosystem) object to represent any PKCS.  This
 296    context implements the PKCS, such as SILC public keys, X.509 certificates,
 297    OpenPGP certificates, etc. under a common API. */
 298 struct SilcPKCSObjectStruct {
 299   /* PKCS type */
 300   SilcPKCSType type;
 301
 302   /* Public key routines */
 303
 304   /* Returns PKCS algorithm context from public key */
 305   SILC_PKCS_GET_ALGORITHM((*get_algorithm));
 306
 307   /* Imports from public key file */
 308   SILC_PKCS_IMPORT_PUBLIC_KEY_FILE((*import_public_key_file));
 309
 310   /* Imports from public key binary data.  Returns the amount of bytes
 311      imported from `key' or 0 on error. */
 312   SILC_PKCS_IMPORT_PUBLIC_KEY((*import_public_key));
 313
 314   /* Exports public key to file */
 315   SILC_PKCS_EXPORT_PUBLIC_KEY_FILE((*export_public_key_file));
 316
 317   /* Export public key as binary data */
 318   SILC_PKCS_EXPORT_PUBLIC_KEY((*export_public_key));
 319
 320   /* Returns key length in bits */
 321   SILC_PKCS_PUBLIC_KEY_BITLEN((*public_key_bitlen));
 322
 323   /* Copy public key */
 324   SILC_PKCS_PUBLIC_KEY_COPY((*public_key_copy));
 325
 326   /* Compares public keys */
 327   SILC_PKCS_PUBLIC_KEY_COMPARE((*public_key_compare));
 328
 329   /* Free public key */
 330   SILC_PKCS_PUBLIC_KEY_FREE((*public_key_free));
 331
 332   /* Private key routines */
 333
 334   /* Imports from private key file */
 335   SILC_PKCS_IMPORT_PRIVATE_KEY_FILE((*import_private_key_file));
 336
 337   /* Imports from private key binary data.  Returns the amount of bytes
 338      imported from `key' or 0 on error. */
 339   SILC_PKCS_IMPORT_PRIVATE_KEY((*import_private_key));
 340
 341   /* Exports private key to file */
 342   SILC_PKCS_EXPORT_PRIVATE_KEY_FILE((*export_private_key_file));
 343
 344   /* Export private key as binary data */
 345   SILC_PKCS_EXPORT_PRIVATE_KEY((*export_private_key));
 346
 347   /* Returns key length in bits */
 348   SILC_PKCS_PRIVATE_KEY_BITLEN((*private_key_bitlen));
 349
 350   /* Free private key */
 351   SILC_PKCS_PRIVATE_KEY_FREE((*private_key_free));
 352
 353   /* Encrypt and decrypt operations */
 354   SILC_PKCS_ENCRYPT((*encrypt));
 355   SILC_PKCS_DECRYPT((*decrypt));
 356
 357   /* Signature and verification operations */
 358   SILC_PKCS_SIGN((*sign));
 359   SILC_PKCS_VERIFY((*verify));
 360 };
 361
 362 /* Backwards support for PKCS API */
 363
 364 #define silc_pkcs_get_context silc_pkcs_public_key_get_pkcs
 365
 366 #endif /* SILCPKCS_I_H */