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