lib/silccrypt/silcpkcs_i.h

   1 /*
   2
   3   silcpkcs_i.h
   4
   5   Author: Pekka Riikonen <priikone@silcnet.org>
   6
   7   Copyright (C) 1997 - 2008 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                           SilcBool compute_hash,                        \
 115                           SilcHash hash,                                \
 116                           SilcRng rng,                                  \
 117                           SilcPKCSVerifyCb verify_cb,                   \
 118                           void *context)
 119
 120 /* The PKCS Algorithm object to represent any PKCS algorithm.  This context
 121    implements the PKCS algorithm, such as RSA, DSA, etc. */
 122 struct SilcPKCSAlgorithmStruct {
 123   /* Algorithm name and scheme */
 124   char *name;                   /* Eg. rsa, dsa, etc. */
 125   char *scheme;                 /* Eg. pkcs1, openpgp, etc. */
 126
 127   /* Supported hash functions, comma separated list */
 128   char *hash;
 129
 130   /* Generate new key pair. Returns PKCS algorithm specific public key
 131      and private key contexts. */
 132   SILC_PKCS_ALG_GENERATE_KEY((*generate_key));
 133
 134   /* Public key routines. */
 135
 136   /* Import/create new public key.  Returns the length of the data that was
 137      imported from `key' or 0 on error.  Returns the PKCS algorithm specific
 138      public key to `ret_public_key'. */
 139   SILC_PKCS_ALG_IMPORT_PUBLIC_KEY((*import_public_key));
 140
 141   /* Export/encode public key.  Returns the encoded public key buffer that
 142      the caller must free. */
 143   SILC_PKCS_ALG_EXPORT_PUBLIC_KEY((*export_public_key));
 144
 145   /* Returns the bit length of public key */
 146   SILC_PKCS_ALG_PUBLIC_KEY_BITLEN((*public_key_bitlen));
 147
 148   /* Duplicated public key */
 149   SILC_PKCS_ALG_PUBLIC_KEY_COPY((*public_key_copy));
 150
 151   /* Compares two public keys.  Returns TRUE if they are identical. */
 152   SILC_PKCS_ALG_PUBLIC_KEY_COMPARE((*public_key_compare));
 153
 154   /* Free public key */
 155   SILC_PKCS_ALG_PUBLIC_KEY_FREE((*public_key_free));
 156
 157   /* Private key routines. */
 158
 159   /* Import/create new private key.  Returns the length of the data that was
 160      imported from `key' or 0 on error.  Returns the PKCS algorithm specific
 161      private key to `ret_private_key'. */
 162   SILC_PKCS_ALG_IMPORT_PRIVATE_KEY((*import_private_key));
 163
 164   /* Export/encode private key.  Returns the encoded private key buffer that
 165      the caller must free. */
 166   SILC_PKCS_ALG_EXPORT_PRIVATE_KEY((*export_private_key));
 167
 168   /* Returns the bi length of private key */
 169   SILC_PKCS_ALG_PRIVATE_KEY_BITLEN((*private_key_bitlen));
 170
 171   /* Free private key */
 172   SILC_PKCS_ALG_PRIVATE_KEY_FREE((*private_key_free));
 173
 174   /* Encrypt and decrypt operations */
 175   SILC_PKCS_ALG_ENCRYPT((*encrypt));
 176   SILC_PKCS_ALG_DECRYPT((*decrypt));
 177
 178   /* Signature and verification operations */
 179   SILC_PKCS_ALG_SIGN((*sign));
 180   SILC_PKCS_ALG_VERIFY((*verify));
 181 };
 182
 183 /* Macros for defining the PKCS APIs.  Use these when you need to declare
 184    PKCS API functions. */
 185
 186 #define SILC_PKCS_GET_ALGORITHM(name)                                   \
 187   const SilcPKCSAlgorithm *name(const struct SilcPKCSObjectStruct *pkcs, \
 188                                 void *public_key)
 189
 190 #define SILC_PKCS_IMPORT_PUBLIC_KEY_FILE(name)                          \
 191   SilcBool name(const struct SilcPKCSObjectStruct *pkcs,                \
 192                 unsigned char *filedata, SilcUInt32 filedata_len,       \
 193                 SilcPKCSFileEncoding encoding, void **ret_public_key,   \
 194                 const struct SilcPKCSAlgorithmStruct **ret_alg)
 195
 196 #define SILC_PKCS_IMPORT_PUBLIC_KEY(name)                               \
 197   int name(const struct SilcPKCSObjectStruct *pkcs,                     \
 198            const struct SilcPKCSAlgorithmStruct *alg,                   \
 199            void *key, SilcUInt32 key_len, void **ret_public_key,        \
 200            const struct SilcPKCSAlgorithmStruct **ret_alg)
 201
 202 #define SILC_PKCS_EXPORT_PUBLIC_KEY_FILE(name)                  \
 203   unsigned char *name(const struct SilcPKCSObjectStruct *pkcs,  \
 204                       SilcStack stack, void *public_key,        \
 205                       SilcPKCSFileEncoding encoding,            \
 206                       SilcUInt32 *ret_len)
 207
 208 #define SILC_PKCS_EXPORT_PUBLIC_KEY(name)                               \
 209   unsigned char *name(const struct SilcPKCSObjectStruct *pkcs,          \
 210                       SilcStack stack, void *public_key, SilcUInt32 *ret_len)
 211
 212 #define SILC_PKCS_PUBLIC_KEY_BITLEN(name)                       \
 213   SilcUInt32 name(const struct SilcPKCSObjectStruct *pkcs,      \
 214                   void *public_key)
 215
 216 #define SILC_PKCS_PUBLIC_KEY_COPY(name)                                 \
 217   void *name(const struct SilcPKCSObjectStruct *pkcs, void *public_key)
 218
 219 #define SILC_PKCS_PUBLIC_KEY_COMPARE(name)                      \
 220   SilcBool name(const struct SilcPKCSObjectStruct *pkcs,        \
 221                 void *key1, void *key2)
 222
 223 #define SILC_PKCS_PUBLIC_KEY_FREE(name)                                 \
 224   void name(const struct SilcPKCSObjectStruct *pkcs, void *public_key)
 225
 226 #define SILC_PKCS_IMPORT_PRIVATE_KEY_FILE(name)                         \
 227   SilcBool name(const struct SilcPKCSObjectStruct *pkcs,                \
 228                 unsigned char *filedata, SilcUInt32 filedata_len,       \
 229                 const char *passphrase, SilcUInt32 passphrase_len,      \
 230                 SilcPKCSFileEncoding encoding, void **ret_private_key,  \
 231                 const struct SilcPKCSAlgorithmStruct **ret_alg)
 232
 233 #define SILC_PKCS_IMPORT_PRIVATE_KEY(name)                              \
 234   int name(const struct SilcPKCSObjectStruct *pkcs,                     \
 235            const struct SilcPKCSAlgorithmStruct *alg,                   \
 236            const char *passphrase, SilcUInt32 passphrase_len,           \
 237            void *key, SilcUInt32 key_len, void **ret_private_key,       \
 238            const struct SilcPKCSAlgorithmStruct **ret_alg)
 239
 240 #define SILC_PKCS_EXPORT_PRIVATE_KEY_FILE(name)                         \
 241   unsigned char *name(const struct SilcPKCSObjectStruct *pkcs,          \
 242                       SilcStack stack, void *private_key,               \
 243                       const char *passphrase, SilcUInt32 passphrase_len, \
 244                       SilcPKCSFileEncoding encoding, SilcRng rng,       \
 245                       SilcUInt32 *ret_len)
 246
 247 #define SILC_PKCS_EXPORT_PRIVATE_KEY(name)                              \
 248   unsigned char *name(const struct SilcPKCSObjectStruct *pkcs,          \
 249                       SilcStack stack, void *private_key, SilcUInt32 *ret_len)
 250
 251 #define SILC_PKCS_PRIVATE_KEY_BITLEN(name)                      \
 252   SilcUInt32 name(const struct SilcPKCSObjectStruct *pkcs, void *private_key)
 253
 254 #define SILC_PKCS_PRIVATE_KEY_FREE(name)                                \
 255   void name(const struct SilcPKCSObjectStruct *pkcs, void *private_key)
 256
 257 #define SILC_PKCS_ENCRYPT(name)                                         \
 258   SilcAsyncOperation name(const struct SilcPKCSObjectStruct *pkcs,      \
 259                           void *public_key,                             \
 260                           unsigned char *src,                           \
 261                           SilcUInt32 src_len,                           \
 262                           SilcRng rng,                                  \
 263                           SilcPKCSEncryptCb encrypt_cb,                 \
 264                           void *context)
 265
 266 #define SILC_PKCS_DECRYPT(name)                                         \
 267   SilcAsyncOperation name(const struct SilcPKCSObjectStruct *pkcs,      \
 268                           void *private_key,                            \
 269                           unsigned char *src,                           \
 270                           SilcUInt32 src_len,                           \
 271                           SilcPKCSDecryptCb decrypt_cb,                 \
 272                           void *context)
 273
 274 #define SILC_PKCS_SIGN(name)                                            \
 275   SilcAsyncOperation name(const struct SilcPKCSObjectStruct *pkcs,      \
 276                           void *private_key,                            \
 277                           unsigned char *src,                           \
 278                           SilcUInt32 src_len,                           \
 279                           SilcBool compute_hash,                        \
 280                           SilcHash hash,                                \
 281                           SilcRng rng,                                  \
 282                           SilcPKCSSignCb sign_cb,                       \
 283                           void *context)
 284
 285 #define SILC_PKCS_VERIFY(name)                                          \
 286   SilcAsyncOperation name(const struct SilcPKCSObjectStruct *pkcs,      \
 287                           void *public_key,                             \
 288                           unsigned char *signature,                     \
 289                           SilcUInt32 signature_len,                     \
 290                           unsigned char *data,                          \
 291                           SilcUInt32 data_len,                          \
 292                           SilcBool compute_hash,                        \
 293                           SilcHash hash,                                \
 294                           SilcRng rng,                                  \
 295                           SilcPKCSVerifyCb verify_cb,                   \
 296                           void *context)
 297
 298 /* The PKCS (Public Key Cryptosystem) object to represent any PKCS.  This
 299    context implements the PKCS, such as SILC public keys, X.509 certificates,
 300    OpenPGP certificates, etc. under a common API. */
 301 struct SilcPKCSObjectStruct {
 302   /* PKCS type */
 303   SilcPKCSType type;
 304
 305   /* Public key routines */
 306
 307   /* Returns PKCS algorithm context from public key */
 308   SILC_PKCS_GET_ALGORITHM((*get_algorithm));
 309
 310   /* Imports from public key file */
 311   SILC_PKCS_IMPORT_PUBLIC_KEY_FILE((*import_public_key_file));
 312
 313   /* Imports from public key binary data.  Returns the amount of bytes
 314      imported from `key' or 0 on error. */
 315   SILC_PKCS_IMPORT_PUBLIC_KEY((*import_public_key));
 316
 317   /* Exports public key to file */
 318   SILC_PKCS_EXPORT_PUBLIC_KEY_FILE((*export_public_key_file));
 319
 320   /* Export public key as binary data */
 321   SILC_PKCS_EXPORT_PUBLIC_KEY((*export_public_key));
 322
 323   /* Returns key length in bits */
 324   SILC_PKCS_PUBLIC_KEY_BITLEN((*public_key_bitlen));
 325
 326   /* Copy public key */
 327   SILC_PKCS_PUBLIC_KEY_COPY((*public_key_copy));
 328
 329   /* Compares public keys */
 330   SILC_PKCS_PUBLIC_KEY_COMPARE((*public_key_compare));
 331
 332   /* Free public key */
 333   SILC_PKCS_PUBLIC_KEY_FREE((*public_key_free));
 334
 335   /* Private key routines */
 336
 337   /* Imports from private key file */
 338   SILC_PKCS_IMPORT_PRIVATE_KEY_FILE((*import_private_key_file));
 339
 340   /* Imports from private key binary data.  Returns the amount of bytes
 341      imported from `key' or 0 on error. */
 342   SILC_PKCS_IMPORT_PRIVATE_KEY((*import_private_key));
 343
 344   /* Exports private key to file */
 345   SILC_PKCS_EXPORT_PRIVATE_KEY_FILE((*export_private_key_file));
 346
 347   /* Export private key as binary data */
 348   SILC_PKCS_EXPORT_PRIVATE_KEY((*export_private_key));
 349
 350   /* Returns key length in bits */
 351   SILC_PKCS_PRIVATE_KEY_BITLEN((*private_key_bitlen));
 352
 353   /* Free private key */
 354   SILC_PKCS_PRIVATE_KEY_FREE((*private_key_free));
 355
 356   /* Encrypt and decrypt operations */
 357   SILC_PKCS_ENCRYPT((*encrypt));
 358   SILC_PKCS_DECRYPT((*decrypt));
 359
 360   /* Signature and verification operations */
 361   SILC_PKCS_SIGN((*sign));
 362   SILC_PKCS_VERIFY((*verify));
 363 };
 364
 365 /* Backwards support for PKCS API */
 366
 367 #define silc_pkcs_get_context silc_pkcs_public_key_get_pkcs
 368
 369 #endif /* SILCPKCS_I_H */