← Back to branch summary

~alinuxninja/nginx-edge/trunk

« back to all changes in this revision

Viewing changes to debian/modules/ngx_pagespeed/psol/include/third_party/boringssl/src/crypto/evp/internal.h

  • Committer: Vivian
  • Date: 2015-12-04 18:20:11 UTC
  • Revision ID: git-v1:a36f2bc32e884f7473b3a47040e5411306144d7d
* Do not extract psol.tar.gz

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/modules/ngx_pagespeed/psol/include/third_party/boringssl/src/crypto/evp/internal.h
1
 
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
2
 
 * All rights reserved.
3
 
 *
4
 
 * This package is an SSL implementation written
5
 
 * by Eric Young (eay@cryptsoft.com).
6
 
 * The implementation was written so as to conform with Netscapes SSL.
7
 
 *
8
 
 * This library is free for commercial and non-commercial use as long as
9
 
 * the following conditions are aheared to.  The following conditions
10
 
 * apply to all code found in this distribution, be it the RC4, RSA,
11
 
 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
12
 
 * included with this distribution is covered by the same copyright terms
13
 
 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
14
 
 *
15
 
 * Copyright remains Eric Young's, and as such any Copyright notices in
16
 
 * the code are not to be removed.
17
 
 * If this package is used in a product, Eric Young should be given attribution
18
 
 * as the author of the parts of the library used.
19
 
 * This can be in the form of a textual message at program startup or
20
 
 * in documentation (online or textual) provided with the package.
21
 
 *
22
 
 * Redistribution and use in source and binary forms, with or without
23
 
 * modification, are permitted provided that the following conditions
24
 
 * are met:
25
 
 * 1. Redistributions of source code must retain the copyright
26
 
 *    notice, this list of conditions and the following disclaimer.
27
 
 * 2. Redistributions in binary form must reproduce the above copyright
28
 
 *    notice, this list of conditions and the following disclaimer in the
29
 
 *    documentation and/or other materials provided with the distribution.
30
 
 * 3. All advertising materials mentioning features or use of this software
31
 
 *    must display the following acknowledgement:
32
 
 *    "This product includes cryptographic software written by
33
 
 *     Eric Young (eay@cryptsoft.com)"
34
 
 *    The word 'cryptographic' can be left out if the rouines from the library
35
 
 *    being used are not cryptographic related :-).
36
 
 * 4. If you include any Windows specific code (or a derivative thereof) from
37
 
 *    the apps directory (application code) you must include an acknowledgement:
38
 
 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
39
 
 *
40
 
 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
41
 
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42
 
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
43
 
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
44
 
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
45
 
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
46
 
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47
 
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
48
 
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
49
 
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
50
 
 * SUCH DAMAGE.
51
 
 *
52
 
 * The licence and distribution terms for any publically available version or
53
 
 * derivative of this code cannot be changed.  i.e. this code cannot simply be
54
 
 * copied and put under another distribution licence
55
 
 * [including the GNU Public Licence.] */
56
 
 
57
 
#ifndef OPENSSL_HEADER_EVP_INTERNAL_H
58
 
#define OPENSSL_HEADER_EVP_INTERNAL_H
59
 
 
60
 
#include <openssl/base.h>
61
 
 
62
 
#if defined(__cplusplus)
63
 
extern "C" {
64
 
#endif
65
 
 
66
 
 
67
 
/* These values are flags for EVP_PKEY_ASN1_METHOD.flags. */
68
 
 
69
 
/* ASN1_PKEY_SIGPARAM_NULL controls whether the default behavior of
70
 
 * EVP_DigestSignAlgorithm writes an explicit NULL parameter in the
71
 
 * AlgorithmIdentifier. */
72
 
#define ASN1_PKEY_SIGPARAM_NULL 0x1
73
 
 
74
 
/* evp_digest_sign_algorithm_result_t is the return value of the
75
 
 * digest_sign_algorithm function in EVP_PKEY_ASN1_METHOD. */
76
 
typedef enum {
77
 
  /* EVP_DIGEST_SIGN_ALGORITHM_ERROR signals an error. */
78
 
  EVP_DIGEST_SIGN_ALGORITHM_ERROR = 0,
79
 
  /* EVP_DIGEST_SIGN_ALGORITHM_SUCCESS signals that the parameters were
80
 
   * serialized in the AlgorithmIdentifier. */
81
 
  EVP_DIGEST_SIGN_ALGORITHM_SUCCESS = 1,
82
 
  /* EVP_DIGEST_SIGN_ALGORITHM_DEFAULT signals that the parameters are
83
 
   * serialized using the default behavior. */
84
 
  EVP_DIGEST_SIGN_ALGORITHM_DEFAULT = 2,
85
 
} evp_digest_sign_algorithm_result_t;
86
 
 
87
 
struct evp_pkey_asn1_method_st {
88
 
  int pkey_id;
89
 
  int pkey_base_id;
90
 
  unsigned long pkey_flags;
91
 
 
92
 
  char *pem_str;
93
 
  char *info;
94
 
 
95
 
  int (*pub_decode)(EVP_PKEY *pk, X509_PUBKEY *pub);
96
 
  int (*pub_encode)(X509_PUBKEY *pub, const EVP_PKEY *pk);
97
 
  int (*pub_cmp)(const EVP_PKEY *a, const EVP_PKEY *b);
98
 
  int (*pub_print)(BIO *out, const EVP_PKEY *pkey, int indent, ASN1_PCTX *pctx);
99
 
 
100
 
  int (*priv_decode)(EVP_PKEY *pk, PKCS8_PRIV_KEY_INFO *p8inf);
101
 
  int (*priv_encode)(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pk);
102
 
  int (*priv_print)(BIO *out, const EVP_PKEY *pkey, int indent,
103
 
                    ASN1_PCTX *pctx);
104
 
 
105
 
  /* pkey_opaque returns 1 if the |pk| is opaque. Opaque keys are backed by
106
 
   * custom implementations which do not expose key material and parameters.*/
107
 
  int (*pkey_opaque)(const EVP_PKEY *pk);
108
 
 
109
 
  /* pkey_supports_digest returns one if |pkey| supports digests of
110
 
   * type |md|. This is intended for use with EVP_PKEYs backing custom
111
 
   * implementations which can't sign all digests. If null, it is
112
 
   * assumed that all digests are supported. */
113
 
  int (*pkey_supports_digest)(const EVP_PKEY *pkey, const EVP_MD *md);
114
 
 
115
 
  int (*pkey_size)(const EVP_PKEY *pk);
116
 
  int (*pkey_bits)(const EVP_PKEY *pk);
117
 
 
118
 
  int (*param_decode)(EVP_PKEY *pkey, const unsigned char **pder, int derlen);
119
 
  int (*param_encode)(const EVP_PKEY *pkey, unsigned char **pder);
120
 
  int (*param_missing)(const EVP_PKEY *pk);
121
 
  int (*param_copy)(EVP_PKEY *to, const EVP_PKEY *from);
122
 
  int (*param_cmp)(const EVP_PKEY *a, const EVP_PKEY *b);
123
 
  int (*param_print)(BIO *out, const EVP_PKEY *pkey, int indent,
124
 
                     ASN1_PCTX *pctx);
125
 
  int (*sig_print)(BIO *out, const X509_ALGOR *sigalg, const ASN1_STRING *sig,
126
 
                   int indent, ASN1_PCTX *pctx);
127
 
 
128
 
 
129
 
  void (*pkey_free)(EVP_PKEY *pkey);
130
 
 
131
 
  /* Legacy functions for old PEM */
132
 
 
133
 
  int (*old_priv_decode)(EVP_PKEY *pkey, const unsigned char **pder,
134
 
                         int derlen);
135
 
  int (*old_priv_encode)(const EVP_PKEY *pkey, unsigned char **pder);
136
 
 
137
 
  /* Converting parameters to/from AlgorithmIdentifier (X509_ALGOR). */
138
 
  int (*digest_verify_init_from_algorithm)(EVP_MD_CTX *ctx,
139
 
                                           X509_ALGOR *algor,
140
 
                                           EVP_PKEY *pkey);
141
 
  evp_digest_sign_algorithm_result_t (*digest_sign_algorithm)(
142
 
      EVP_MD_CTX *ctx,
143
 
      X509_ALGOR *algor);
144
 
 
145
 
} /* EVP_PKEY_ASN1_METHOD */;
146
 
 
147
 
 
148
 
typedef int EVP_PKEY_gen_cb(EVP_PKEY_CTX *ctx);
149
 
 
150
 
#define EVP_PKEY_OP_UNDEFINED 0
151
 
#define EVP_PKEY_OP_PARAMGEN (1 << 1)
152
 
#define EVP_PKEY_OP_KEYGEN (1 << 2)
153
 
#define EVP_PKEY_OP_SIGN (1 << 3)
154
 
#define EVP_PKEY_OP_VERIFY (1 << 4)
155
 
#define EVP_PKEY_OP_VERIFYRECOVER (1 << 5)
156
 
#define EVP_PKEY_OP_SIGNCTX (1 << 6)
157
 
#define EVP_PKEY_OP_VERIFYCTX (1 << 7)
158
 
#define EVP_PKEY_OP_ENCRYPT (1 << 8)
159
 
#define EVP_PKEY_OP_DECRYPT (1 << 9)
160
 
#define EVP_PKEY_OP_DERIVE (1 << 10)
161
 
 
162
 
#define EVP_PKEY_OP_TYPE_SIG                                           \
163
 
  (EVP_PKEY_OP_SIGN | EVP_PKEY_OP_VERIFY | EVP_PKEY_OP_VERIFYRECOVER | \
164
 
   EVP_PKEY_OP_SIGNCTX | EVP_PKEY_OP_VERIFYCTX)
165
 
 
166
 
#define EVP_PKEY_OP_TYPE_CRYPT (EVP_PKEY_OP_ENCRYPT | EVP_PKEY_OP_DECRYPT)
167
 
 
168
 
#define EVP_PKEY_OP_TYPE_NOGEN \
169
 
  (EVP_PKEY_OP_SIG | EVP_PKEY_OP_CRYPT | EVP_PKEY_OP_DERIVE)
170
 
 
171
 
#define EVP_PKEY_OP_TYPE_GEN (EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN)
172
 
 
173
 
/* EVP_PKEY_CTX_ctrl performs |cmd| on |ctx|. The |keytype| and |optype|
174
 
 * arguments can be -1 to specify that any type and operation are acceptable,
175
 
 * otherwise |keytype| must match the type of |ctx| and the bits of |optype|
176
 
 * must intersect the operation flags set on |ctx|.
177
 
 *
178
 
 * The |p1| and |p2| arguments depend on the value of |cmd|.
179
 
 *
180
 
 * It returns one on success and zero on error. */
181
 
OPENSSL_EXPORT int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype,
182
 
                                     int cmd, int p1, void *p2);
183
 
 
184
 
/* EVP_PKEY_CTRL_DIGESTINIT is an internal value. It's called by
185
 
 * EVP_DigestInit_ex to signal the |EVP_PKEY| that a digest operation is
186
 
 * starting.
187
 
 *
188
 
 * TODO(davidben): This is only needed to support the deprecated HMAC |EVP_PKEY|
189
 
 * types. */
190
 
#define EVP_PKEY_CTRL_DIGESTINIT 3
191
 
 
192
 
/* EVP_PKEY_CTRL_PEER_KEY is called with different values of |p1|:
193
 
 *   0: Is called from |EVP_PKEY_derive_set_peer| and |p2| contains a peer key.
194
 
 *      If the return value is <= 0, the key is rejected.
195
 
 *   1: Is called at the end of |EVP_PKEY_derive_set_peer| and |p2| contains a
196
 
 *      peer key. If the return value is <= 0, the key is rejected.
197
 
 *   2: Is called with |p2| == NULL to test whether the peer's key was used.
198
 
 *      (EC)DH always return one in this case.
199
 
 *   3: Is called with |p2| == NULL to set whether the peer's key was used.
200
 
 *      (EC)DH always return one in this case. This was only used for GOST. */
201
 
#define EVP_PKEY_CTRL_PEER_KEY 4
202
 
 
203
 
/* EVP_PKEY_CTRL_SET_MAC_KEY sets a MAC key. For example, this can be done an
204
 
 * |EVP_PKEY_CTX| prior to calling |EVP_PKEY_keygen| in order to generate an
205
 
 * HMAC |EVP_PKEY| with the given key. It returns one on success and zero on
206
 
 * error. */
207
 
#define EVP_PKEY_CTRL_SET_MAC_KEY 5
208
 
 
209
 
/* EVP_PKEY_ALG_CTRL is the base value from which key-type specific ctrl
210
 
 * commands are numbered. */
211
 
#define EVP_PKEY_ALG_CTRL 0x1000
212
 
 
213
 
#define EVP_PKEY_CTRL_MD 1
214
 
#define EVP_PKEY_CTRL_GET_MD 2
215
 
 
216
 
#define EVP_PKEY_CTRL_RSA_PADDING (EVP_PKEY_ALG_CTRL + 1)
217
 
#define EVP_PKEY_CTRL_GET_RSA_PADDING (EVP_PKEY_ALG_CTRL + 2)
218
 
#define EVP_PKEY_CTRL_RSA_PSS_SALTLEN (EVP_PKEY_ALG_CTRL + 3)
219
 
#define EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN (EVP_PKEY_ALG_CTRL + 4)
220
 
#define EVP_PKEY_CTRL_RSA_KEYGEN_BITS (EVP_PKEY_ALG_CTRL + 5)
221
 
#define EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP (EVP_PKEY_ALG_CTRL + 6)
222
 
#define EVP_PKEY_CTRL_RSA_OAEP_MD (EVP_PKEY_ALG_CTRL + 7)
223
 
#define EVP_PKEY_CTRL_GET_RSA_OAEP_MD (EVP_PKEY_ALG_CTRL + 8)
224
 
#define EVP_PKEY_CTRL_RSA_MGF1_MD (EVP_PKEY_ALG_CTRL + 9)
225
 
#define EVP_PKEY_CTRL_GET_RSA_MGF1_MD (EVP_PKEY_ALG_CTRL + 10)
226
 
#define EVP_PKEY_CTRL_RSA_OAEP_LABEL (EVP_PKEY_ALG_CTRL + 11)
227
 
#define EVP_PKEY_CTRL_GET_RSA_OAEP_LABEL (EVP_PKEY_ALG_CTRL + 12)
228
 
 
229
 
#define EVP_PKEY_CTRL_EC_PARAMGEN_CURVE_NID (EVP_PKEY_ALG_CTRL + 1)
230
 
 
231
 
struct evp_pkey_ctx_st {
232
 
  /* Method associated with this operation */
233
 
  const EVP_PKEY_METHOD *pmeth;
234
 
  /* Engine that implements this method or NULL if builtin */
235
 
  ENGINE *engine;
236
 
  /* Key: may be NULL */
237
 
  EVP_PKEY *pkey;
238
 
  /* Peer key for key agreement, may be NULL */
239
 
  EVP_PKEY *peerkey;
240
 
  /* operation contains one of the |EVP_PKEY_OP_*| values. */
241
 
  int operation;
242
 
  /* Algorithm specific data */
243
 
  void *data;
244
 
  /* Application specific data */
245
 
  void *app_data;
246
 
} /* EVP_PKEY_CTX */;
247
 
 
248
 
struct evp_pkey_method_st {
249
 
  int pkey_id;
250
 
  int flags;
251
 
 
252
 
  int (*init)(EVP_PKEY_CTX *ctx);
253
 
  int (*copy)(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src);
254
 
  void (*cleanup)(EVP_PKEY_CTX *ctx);
255
 
 
256
 
  int (*paramgen_init)(EVP_PKEY_CTX *ctx);
257
 
  int (*paramgen)(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey);
258
 
 
259
 
  int (*keygen_init)(EVP_PKEY_CTX *ctx);
260
 
  int (*keygen)(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey);
261
 
 
262
 
  int (*sign_init)(EVP_PKEY_CTX *ctx);
263
 
  int (*sign)(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
264
 
              const unsigned char *tbs, size_t tbslen);
265
 
 
266
 
  int (*verify_init)(EVP_PKEY_CTX *ctx);
267
 
  int (*verify)(EVP_PKEY_CTX *ctx, const unsigned char *sig, size_t siglen,
268
 
                const unsigned char *tbs, size_t tbslen);
269
 
 
270
 
  int (*signctx_init)(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx);
271
 
  int (*signctx)(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
272
 
                 EVP_MD_CTX *mctx);
273
 
 
274
 
  int (*verifyctx_init)(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx);
275
 
  int (*verifyctx)(EVP_PKEY_CTX *ctx, const unsigned char *sig, int siglen,
276
 
                   EVP_MD_CTX *mctx);
277
 
 
278
 
  int (*encrypt_init)(EVP_PKEY_CTX *ctx);
279
 
  int (*encrypt)(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
280
 
                 const unsigned char *in, size_t inlen);
281
 
 
282
 
  int (*decrypt_init)(EVP_PKEY_CTX *ctx);
283
 
  int (*decrypt)(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
284
 
                 const unsigned char *in, size_t inlen);
285
 
 
286
 
  int (*derive_init)(EVP_PKEY_CTX *ctx);
287
 
  int (*derive)(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen);
288
 
 
289
 
  int (*ctrl)(EVP_PKEY_CTX *ctx, int type, int p1, void *p2);
290
 
  int (*ctrl_str)(EVP_PKEY_CTX *ctx, const char *type, const char *value);
291
 
} /* EVP_PKEY_METHOD */;
292
 
 
293
 
 
294
 
#if defined(__cplusplus)
295
 
}  /* extern C */
296
 
#endif
297
 
 
298
 
#endif  /* OPENSSL_HEADER_EVP_INTERNAL_H */