dlls/bcrypt/bcrypt_internal.h

   1 /*
   2  * Copyright 2016 Michael Müller
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  *
  18  */
  19
  20 #ifndef __BCRYPT_INTERNAL_H
  21 #define __BCRYPT_INTERNAL_H
  22
  23 #include <stdarg.h>
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winternl.h"
  28 #include "wincrypt.h"
  29 #include "bcrypt.h"
  30 #include "wine/unixlib.h"
  31
  32 #define MAGIC_DSS1 ('D' | ('S' << 8) | ('S' << 16) | ('1' << 24))
  33 #define MAGIC_DSS2 ('D' | ('S' << 8) | ('S' << 16) | ('2' << 24))
  34
  35 typedef struct
  36 {
  37     ULONG64 len;
  38     DWORD h[8];
  39     UCHAR buf[64];
  40 } SHA256_CTX;
  41
  42 void sha256_init(SHA256_CTX *ctx);
  43 void sha256_update(SHA256_CTX *ctx, const UCHAR *buffer, ULONG len);
  44 void sha256_finalize(SHA256_CTX *ctx, UCHAR *buffer);
  45
  46 typedef struct
  47 {
  48   ULONG64 len;
  49   ULONG64 h[8];
  50   UCHAR buf[128];
  51 } SHA512_CTX;
  52
  53 void sha512_init(SHA512_CTX *ctx);
  54 void sha512_update(SHA512_CTX *ctx, const UCHAR *buffer, ULONG len);
  55 void sha512_finalize(SHA512_CTX *ctx, UCHAR *buffer);
  56
  57 void sha384_init(SHA512_CTX *ctx);
  58 #define sha384_update sha512_update
  59 void sha384_finalize(SHA512_CTX *ctx, UCHAR *buffer);
  60
  61 typedef struct {
  62     unsigned char chksum[16], X[48], buf[16];
  63     unsigned long curlen;
  64 } MD2_CTX;
  65
  66 void md2_init(MD2_CTX *ctx);
  67 void md2_update(MD2_CTX *ctx, const unsigned char *buf, ULONG len);
  68 void md2_finalize(MD2_CTX *ctx, unsigned char *hash);
  69
  70 /* Definitions from advapi32 */
  71 typedef struct tagMD4_CTX {
  72     unsigned int buf[4];
  73     unsigned int i[2];
  74     unsigned char in[64];
  75     unsigned char digest[16];
  76 } MD4_CTX;
  77
  78 VOID WINAPI MD4Init(MD4_CTX *ctx);
  79 VOID WINAPI MD4Update(MD4_CTX *ctx, const unsigned char *buf, unsigned int len);
  80 VOID WINAPI MD4Final(MD4_CTX *ctx);
  81
  82 typedef struct
  83 {
  84     unsigned int i[2];
  85     unsigned int buf[4];
  86     unsigned char in[64];
  87     unsigned char digest[16];
  88 } MD5_CTX;
  89
  90 VOID WINAPI MD5Init(MD5_CTX *ctx);
  91 VOID WINAPI MD5Update(MD5_CTX *ctx, const unsigned char *buf, unsigned int len);
  92 VOID WINAPI MD5Final(MD5_CTX *ctx);
  93
  94 typedef struct
  95 {
  96    ULONG Unknown[6];
  97    ULONG State[5];
  98    ULONG Count[2];
  99    UCHAR Buffer[64];
 100 } SHA_CTX;
 101
 102 VOID WINAPI A_SHAInit(SHA_CTX *ctx);
 103 VOID WINAPI A_SHAUpdate(SHA_CTX *ctx, const UCHAR *buffer, UINT size);
 104 VOID WINAPI A_SHAFinal(SHA_CTX *ctx, PULONG result);
 105
 106 #define MAGIC_ALG  (('A' << 24) | ('L' << 16) | ('G' << 8) | '0')
 107 #define MAGIC_HASH (('H' << 24) | ('A' << 16) | ('S' << 8) | 'H')
 108 #define MAGIC_KEY  (('K' << 24) | ('E' << 16) | ('Y' << 8) | '0')
 109 #define MAGIC_SECRET (('S' << 24) | ('C' << 16) | ('R' << 8) | 'T')
 110 struct object
 111 {
 112     ULONG magic;
 113 };
 114
 115 enum alg_id
 116 {
 117     /* cipher */
 118     ALG_ID_3DES,
 119     ALG_ID_AES,
 120     ALG_ID_RC4,
 121
 122     /* hash */
 123     ALG_ID_SHA256,
 124     ALG_ID_SHA384,
 125     ALG_ID_SHA512,
 126     ALG_ID_SHA1,
 127     ALG_ID_MD5,
 128     ALG_ID_MD4,
 129     ALG_ID_MD2,
 130
 131     /* asymmetric encryption */
 132     ALG_ID_RSA,
 133
 134     /* secret agreement */
 135     ALG_ID_DH,
 136     ALG_ID_ECDH_P256,
 137     ALG_ID_ECDH_P384,
 138
 139     /* signature */
 140     ALG_ID_RSA_SIGN,
 141     ALG_ID_ECDSA_P256,
 142     ALG_ID_ECDSA_P384,
 143     ALG_ID_DSA,
 144
 145     /* rng */
 146     ALG_ID_RNG,
 147 };
 148
 149 enum chain_mode
 150 {
 151     CHAIN_MODE_CBC,
 152     CHAIN_MODE_ECB,
 153     CHAIN_MODE_CFB,
 154     CHAIN_MODE_CCM,
 155     CHAIN_MODE_GCM,
 156 };
 157
 158 struct algorithm
 159 {
 160     struct object   hdr;
 161     enum alg_id     id;
 162     enum chain_mode mode;
 163     unsigned        flags;
 164 };
 165
 166 struct key_symmetric
 167 {
 168     enum chain_mode  mode;
 169     ULONG            block_size;
 170     UCHAR           *vector;
 171     ULONG            vector_len;
 172     UCHAR           *secret;
 173     unsigned         secret_len;
 174     CRITICAL_SECTION cs;
 175 };
 176
 177 #define KEY_FLAG_LEGACY_DSA_V2  0x00000001
 178 #define KEY_FLAG_FINALIZED      0x00000002
 179
 180 struct key_asymmetric
 181 {
 182     ULONG             bitlen;     /* ignored for ECC keys */
 183     unsigned          flags;
 184     DSSSEED           dss_seed;
 185 };
 186
 187 #define PRIVATE_DATA_SIZE 3
 188 struct key
 189 {
 190     struct object hdr;
 191     enum alg_id   alg_id;
 192     UINT64        private[PRIVATE_DATA_SIZE];  /* private data for backend */
 193     union
 194     {
 195         struct key_symmetric s;
 196         struct key_asymmetric a;
 197     } u;
 198 };
 199
 200 struct secret
 201 {
 202     struct object hdr;
 203     struct key *privkey;
 204     struct key *pubkey;
 205 };
 206
 207 struct key_symmetric_set_auth_data_params
 208 {
 209     struct key  *key;
 210     UCHAR       *auth_data;
 211     ULONG        len;
 212 };
 213
 214 struct key_symmetric_encrypt_params
 215 {
 216     struct key  *key;
 217     const UCHAR *input;
 218     unsigned     input_len;
 219     UCHAR       *output;
 220     ULONG        output_len;
 221 };
 222
 223 struct key_symmetric_decrypt_params
 224 {
 225     struct key  *key;
 226     const UCHAR *input;
 227     unsigned     input_len;
 228     UCHAR       *output;
 229     ULONG        output_len;
 230 };
 231
 232 struct key_symmetric_get_tag_params
 233 {
 234     struct key  *key;
 235     UCHAR       *tag;
 236     ULONG        len;
 237 };
 238
 239 struct key_asymmetric_decrypt_params
 240 {
 241     struct key  *key;
 242     UCHAR       *input;
 243     unsigned     input_len;
 244     void        *padding;
 245     UCHAR       *output;
 246     ULONG        output_len;
 247     ULONG       *ret_len;
 248     ULONG        flags;
 249 };
 250
 251 struct key_asymmetric_encrypt_params
 252 {
 253     struct key  *key;
 254     UCHAR       *input;
 255     unsigned     input_len;
 256     void        *padding;
 257     UCHAR       *output;
 258     ULONG        output_len;
 259     ULONG       *ret_len;
 260     ULONG        flags;
 261 };
 262
 263 struct key_asymmetric_duplicate_params
 264 {
 265     struct key *key_orig;
 266     struct key *key_copy;
 267 };
 268
 269 struct key_asymmetric_sign_params
 270 {
 271     struct key  *key;
 272     void        *padding;
 273     UCHAR       *input;
 274     unsigned     input_len;
 275     UCHAR       *output;
 276     ULONG        output_len;
 277     ULONG       *ret_len;
 278     unsigned     flags;
 279 };
 280
 281 struct key_asymmetric_verify_params
 282 {
 283     struct key *key;
 284     void       *padding;
 285     UCHAR      *hash;
 286     unsigned    hash_len;
 287     UCHAR      *signature;
 288     ULONG       signature_len;
 289     unsigned    flags;
 290 };
 291
 292 #define KEY_EXPORT_FLAG_PUBLIC        0x00000001
 293 #define KEY_EXPORT_FLAG_RSA_FULL      0x00000002
 294 #define KEY_EXPORT_FLAG_DH_PARAMETERS 0x00000004
 295
 296 struct key_asymmetric_export_params
 297 {
 298     struct key  *key;
 299     ULONG        flags;
 300     UCHAR       *buf;
 301     ULONG        len;
 302     ULONG       *ret_len;
 303 };
 304
 305 #define KEY_IMPORT_FLAG_PUBLIC        0x00000001
 306 #define KEY_IMPORT_FLAG_DH_PARAMETERS 0x00000002
 307
 308 struct key_asymmetric_import_params
 309 {
 310     struct key  *key;
 311     ULONG        flags;
 312     UCHAR       *buf;
 313     ULONG        len;
 314 };
 315
 316 struct key_asymmetric_derive_key_params
 317 {
 318     struct key *privkey;
 319     struct key *pubkey;
 320     UCHAR      *output;
 321     ULONG       output_len;
 322     ULONG      *ret_len;
 323 };
 324
 325 enum key_funcs
 326 {
 327     unix_process_attach,
 328     unix_process_detach,
 329     unix_key_symmetric_vector_reset,
 330     unix_key_symmetric_set_auth_data,
 331     unix_key_symmetric_encrypt,
 332     unix_key_symmetric_decrypt,
 333     unix_key_symmetric_get_tag,
 334     unix_key_symmetric_destroy,
 335     unix_key_asymmetric_generate,
 336     unix_key_asymmetric_decrypt,
 337     unix_key_asymmetric_encrypt,
 338     unix_key_asymmetric_duplicate,
 339     unix_key_asymmetric_sign,
 340     unix_key_asymmetric_verify,
 341     unix_key_asymmetric_destroy,
 342     unix_key_asymmetric_export,
 343     unix_key_asymmetric_import,
 344     unix_key_asymmetric_derive_key,
 345     unix_funcs_count,
 346 };
 347
 348 #endif /* __BCRYPT_INTERNAL_H */