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) DECLSPEC_HIDDEN;
  43 void sha256_update(SHA256_CTX *ctx, const UCHAR *buffer, ULONG len) DECLSPEC_HIDDEN;
  44 void sha256_finalize(SHA256_CTX *ctx, UCHAR *buffer) DECLSPEC_HIDDEN;
  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) DECLSPEC_HIDDEN;
  54 void sha512_update(SHA512_CTX *ctx, const UCHAR *buffer, ULONG len) DECLSPEC_HIDDEN;
  55 void sha512_finalize(SHA512_CTX *ctx, UCHAR *buffer) DECLSPEC_HIDDEN;
  56
  57 void sha384_init(SHA512_CTX *ctx) DECLSPEC_HIDDEN;
  58 #define sha384_update sha512_update
  59 void sha384_finalize(SHA512_CTX *ctx, UCHAR *buffer) DECLSPEC_HIDDEN;
  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) DECLSPEC_HIDDEN;
  67 void md2_update(MD2_CTX *ctx, const unsigned char *buf, ULONG len) DECLSPEC_HIDDEN;
  68 void md2_finalize(MD2_CTX *ctx, unsigned char *hash) DECLSPEC_HIDDEN;
  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
 121     /* hash */
 122     ALG_ID_SHA256,
 123     ALG_ID_SHA384,
 124     ALG_ID_SHA512,
 125     ALG_ID_SHA1,
 126     ALG_ID_MD5,
 127     ALG_ID_MD4,
 128     ALG_ID_MD2,
 129
 130     /* asymmetric encryption */
 131     ALG_ID_RSA,
 132
 133     /* secret agreement */
 134     ALG_ID_ECDH_P256,
 135
 136     /* signature */
 137     ALG_ID_RSA_SIGN,
 138     ALG_ID_ECDSA_P256,
 139     ALG_ID_ECDSA_P384,
 140     ALG_ID_DSA,
 141
 142     /* rng */
 143     ALG_ID_RNG,
 144 };
 145
 146 enum mode_id
 147 {
 148     MODE_ID_ECB,
 149     MODE_ID_CBC,
 150     MODE_ID_GCM
 151 };
 152
 153 struct algorithm
 154 {
 155     struct object hdr;
 156     enum alg_id   id;
 157     enum mode_id  mode;
 158     unsigned      flags;
 159 };
 160
 161 struct key_symmetric
 162 {
 163     enum mode_id mode;
 164     ULONG        block_size;
 165     UCHAR       *vector;
 166     ULONG        vector_len;
 167     UCHAR       *secret;
 168     unsigned     secret_len;
 169     CRITICAL_SECTION cs;
 170 };
 171
 172 #define KEY_FLAG_LEGACY_DSA_V2  0x00000001
 173
 174 struct key_asymmetric
 175 {
 176     ULONG             bitlen;     /* ignored for ECC keys */
 177     unsigned          flags;
 178     DSSSEED           dss_seed;
 179 };
 180
 181 struct key
 182 {
 183     struct object hdr;
 184     enum alg_id   alg_id;
 185     UINT64        private[2];  /* private data for backend */
 186     union
 187     {
 188         struct key_symmetric s;
 189         struct key_asymmetric a;
 190     } u;
 191 };
 192
 193 struct secret
 194 {
 195     struct object hdr;
 196 };
 197
 198 struct key_symmetric_set_auth_data_params
 199 {
 200     struct key  *key;
 201     UCHAR       *auth_data;
 202     ULONG        len;
 203 };
 204
 205 struct key_symmetric_encrypt_params
 206 {
 207     struct key  *key;
 208     const UCHAR *input;
 209     unsigned     input_len;
 210     UCHAR       *output;
 211     ULONG        output_len;
 212 };
 213
 214 struct key_symmetric_decrypt_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_get_tag_params
 224 {
 225     struct key  *key;
 226     UCHAR       *tag;
 227     ULONG        len;
 228 };
 229
 230 struct key_asymmetric_decrypt_params
 231 {
 232     struct key  *key;
 233     UCHAR       *input;
 234     unsigned     input_len;
 235     UCHAR       *output;
 236     ULONG        output_len;
 237     ULONG       *ret_len;
 238 };
 239
 240 struct key_asymmetric_duplicate_params
 241 {
 242     struct key  *key_orig;
 243     struct key  *key_copy;
 244 };
 245
 246 struct key_asymmetric_sign_params
 247 {
 248     struct key  *key;
 249     void        *padding;
 250     UCHAR       *input;
 251     unsigned     input_len;
 252     UCHAR       *output;
 253     ULONG        output_len;
 254     ULONG       *ret_len;
 255     unsigned     flags;
 256 };
 257
 258 struct key_asymmetric_verify_params
 259 {
 260     struct key *key;
 261     void       *padding;
 262     UCHAR      *hash;
 263     unsigned    hash_len;
 264     UCHAR      *signature;
 265     ULONG       signature_len;
 266     unsigned    flags;
 267 };
 268
 269 #define KEY_EXPORT_FLAG_PUBLIC   0x00000001
 270 #define KEY_EXPORT_FLAG_RSA_FULL 0x00000002
 271 struct key_asymmetric_export_params
 272 {
 273     struct key  *key;
 274     ULONG        flags;
 275     UCHAR       *buf;
 276     ULONG        len;
 277     ULONG       *ret_len;
 278 };
 279
 280 #define KEY_IMPORT_FLAG_PUBLIC   0x00000001
 281 struct key_asymmetric_import_params
 282 {
 283     struct key  *key;
 284     ULONG        flags;
 285     UCHAR       *buf;
 286     ULONG        len;
 287 };
 288
 289 enum key_funcs
 290 {
 291     unix_process_attach,
 292     unix_process_detach,
 293     unix_key_symmetric_vector_reset,
 294     unix_key_symmetric_set_auth_data,
 295     unix_key_symmetric_encrypt,
 296     unix_key_symmetric_decrypt,
 297     unix_key_symmetric_get_tag,
 298     unix_key_symmetric_destroy,
 299     unix_key_asymmetric_generate,
 300     unix_key_asymmetric_decrypt,
 301     unix_key_asymmetric_duplicate,
 302     unix_key_asymmetric_sign,
 303     unix_key_asymmetric_verify,
 304     unix_key_asymmetric_destroy,
 305     unix_key_asymmetric_export,
 306     unix_key_asymmetric_import,
 307 };
 308
 309 #endif /* __BCRYPT_INTERNAL_H */