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     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_ECDH_P256,
 136     ALG_ID_ECDH_P384,
 137
 138     /* signature */
 139     ALG_ID_RSA_SIGN,
 140     ALG_ID_ECDSA_P256,
 141     ALG_ID_ECDSA_P384,
 142     ALG_ID_DSA,
 143
 144     /* rng */
 145     ALG_ID_RNG,
 146 };
 147
 148 enum chain_mode
 149 {
 150     CHAIN_MODE_CBC,
 151     CHAIN_MODE_ECB,
 152     CHAIN_MODE_CFB,
 153     CHAIN_MODE_CCM,
 154     CHAIN_MODE_GCM,
 155 };
 156
 157 struct algorithm
 158 {
 159     struct object   hdr;
 160     enum alg_id     id;
 161     enum chain_mode mode;
 162     unsigned        flags;
 163 };
 164
 165 struct key_symmetric
 166 {
 167     enum chain_mode  mode;
 168     ULONG            block_size;
 169     UCHAR           *vector;
 170     ULONG            vector_len;
 171     UCHAR           *secret;
 172     unsigned         secret_len;
 173     CRITICAL_SECTION cs;
 174 };
 175
 176 #define KEY_FLAG_LEGACY_DSA_V2  0x00000001
 177
 178 struct key_asymmetric
 179 {
 180     ULONG             bitlen;     /* ignored for ECC keys */
 181     unsigned          flags;
 182     DSSSEED           dss_seed;
 183 };
 184
 185 struct key
 186 {
 187     struct object hdr;
 188     enum alg_id   alg_id;
 189     UINT64        private[2];  /* private data for backend */
 190     union
 191     {
 192         struct key_symmetric s;
 193         struct key_asymmetric a;
 194     } u;
 195 };
 196
 197 struct secret
 198 {
 199     struct object hdr;
 200 };
 201
 202 struct key_symmetric_set_auth_data_params
 203 {
 204     struct key  *key;
 205     UCHAR       *auth_data;
 206     ULONG        len;
 207 };
 208
 209 struct key_symmetric_encrypt_params
 210 {
 211     struct key  *key;
 212     const UCHAR *input;
 213     unsigned     input_len;
 214     UCHAR       *output;
 215     ULONG        output_len;
 216 };
 217
 218 struct key_symmetric_decrypt_params
 219 {
 220     struct key  *key;
 221     const UCHAR *input;
 222     unsigned     input_len;
 223     UCHAR       *output;
 224     ULONG        output_len;
 225 };
 226
 227 struct key_symmetric_get_tag_params
 228 {
 229     struct key  *key;
 230     UCHAR       *tag;
 231     ULONG        len;
 232 };
 233
 234 struct key_asymmetric_decrypt_params
 235 {
 236     struct key  *key;
 237     UCHAR       *input;
 238     unsigned     input_len;
 239     UCHAR       *output;
 240     ULONG        output_len;
 241     ULONG       *ret_len;
 242 };
 243
 244 struct key_asymmetric_encrypt_params
 245 {
 246     struct key  *key;
 247     UCHAR       *input;
 248     unsigned    input_len;
 249     UCHAR       *output;
 250     ULONG       output_len;
 251     ULONG       *ret_len;
 252 };
 253
 254 struct key_asymmetric_duplicate_params
 255 {
 256     struct key  *key_orig;
 257     struct key  *key_copy;
 258 };
 259
 260 struct key_asymmetric_sign_params
 261 {
 262     struct key  *key;
 263     void        *padding;
 264     UCHAR       *input;
 265     unsigned     input_len;
 266     UCHAR       *output;
 267     ULONG        output_len;
 268     ULONG       *ret_len;
 269     unsigned     flags;
 270 };
 271
 272 struct key_asymmetric_verify_params
 273 {
 274     struct key *key;
 275     void       *padding;
 276     UCHAR      *hash;
 277     unsigned    hash_len;
 278     UCHAR      *signature;
 279     ULONG       signature_len;
 280     unsigned    flags;
 281 };
 282
 283 #define KEY_EXPORT_FLAG_PUBLIC   0x00000001
 284 #define KEY_EXPORT_FLAG_RSA_FULL 0x00000002
 285 struct key_asymmetric_export_params
 286 {
 287     struct key  *key;
 288     ULONG        flags;
 289     UCHAR       *buf;
 290     ULONG        len;
 291     ULONG       *ret_len;
 292 };
 293
 294 #define KEY_IMPORT_FLAG_PUBLIC   0x00000001
 295 struct key_asymmetric_import_params
 296 {
 297     struct key  *key;
 298     ULONG        flags;
 299     UCHAR       *buf;
 300     ULONG        len;
 301 };
 302
 303 enum key_funcs
 304 {
 305     unix_process_attach,
 306     unix_process_detach,
 307     unix_key_symmetric_vector_reset,
 308     unix_key_symmetric_set_auth_data,
 309     unix_key_symmetric_encrypt,
 310     unix_key_symmetric_decrypt,
 311     unix_key_symmetric_get_tag,
 312     unix_key_symmetric_destroy,
 313     unix_key_asymmetric_generate,
 314     unix_key_asymmetric_decrypt,
 315     unix_key_asymmetric_encrypt,
 316     unix_key_asymmetric_duplicate,
 317     unix_key_asymmetric_sign,
 318     unix_key_asymmetric_verify,
 319     unix_key_asymmetric_destroy,
 320     unix_key_asymmetric_export,
 321     unix_key_asymmetric_import,
 322 };
 323
 324 #endif /* __BCRYPT_INTERNAL_H */