diff options
Diffstat (limited to '')
| -rw-r--r-- | src/lib/libcrypto/rsa/rsa.h | 324 | ||||
| -rw-r--r-- | src/lib/libcrypto/rsa/rsa_eay.c | 274 | ||||
| -rw-r--r-- | src/lib/libcrypto/rsa/rsa_err.c | 129 | ||||
| -rw-r--r-- | src/lib/libcrypto/rsa/rsa_gen.c | 101 | ||||
| -rw-r--r-- | src/lib/libcrypto/rsa/rsa_lib.c | 294 | ||||
| -rw-r--r-- | src/lib/libcrypto/rsa/rsa_none.c | 109 | ||||
| -rw-r--r-- | src/lib/libcrypto/rsa/rsa_pk1.c | 233 | ||||
| -rw-r--r-- | src/lib/libcrypto/rsa/rsa_saos.c | 153 | ||||
| -rw-r--r-- | src/lib/libcrypto/rsa/rsa_sign.c | 196 | ||||
| -rw-r--r-- | src/lib/libcrypto/rsa/rsa_ssl.c | 153 |
10 files changed, 1966 insertions, 0 deletions
diff --git a/src/lib/libcrypto/rsa/rsa.h b/src/lib/libcrypto/rsa/rsa.h new file mode 100644 index 0000000000..aeb78ffcd3 --- /dev/null +++ b/src/lib/libcrypto/rsa/rsa.h | |||
| @@ -0,0 +1,324 @@ | |||
| 1 | /* crypto/rsa/rsa.h */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #ifndef HEADER_RSA_H | ||
| 60 | #define HEADER_RSA_H | ||
| 61 | |||
| 62 | #ifdef __cplusplus | ||
| 63 | extern "C" { | ||
| 64 | #endif | ||
| 65 | |||
| 66 | #include "bn.h" | ||
| 67 | #include "crypto.h" | ||
| 68 | |||
| 69 | typedef struct rsa_meth_st | ||
| 70 | { | ||
| 71 | char *name; | ||
| 72 | int (*rsa_pub_enc)(); | ||
| 73 | int (*rsa_pub_dec)(); | ||
| 74 | int (*rsa_priv_enc)(); | ||
| 75 | int (*rsa_priv_dec)(); | ||
| 76 | int (*rsa_mod_exp)(); /* Can be null */ | ||
| 77 | int (*bn_mod_exp)(); /* Can be null */ | ||
| 78 | int (*init)(/* RSA * */); /* called at new */ | ||
| 79 | int (*finish)(/* RSA * */); /* called at free */ | ||
| 80 | |||
| 81 | int flags; /* RSA_METHOD_FLAG_* things */ | ||
| 82 | char *app_data; /* may be needed! */ | ||
| 83 | } RSA_METHOD; | ||
| 84 | |||
| 85 | typedef struct rsa_st | ||
| 86 | { | ||
| 87 | /* The first parameter is used to pickup errors where | ||
| 88 | * this is passed instead of aEVP_PKEY, it is set to 0 */ | ||
| 89 | int pad; | ||
| 90 | int version; | ||
| 91 | RSA_METHOD *meth; | ||
| 92 | BIGNUM *n; | ||
| 93 | BIGNUM *e; | ||
| 94 | BIGNUM *d; | ||
| 95 | BIGNUM *p; | ||
| 96 | BIGNUM *q; | ||
| 97 | BIGNUM *dmp1; | ||
| 98 | BIGNUM *dmq1; | ||
| 99 | BIGNUM *iqmp; | ||
| 100 | /* be carefull using this if the RSA structure is shared */ | ||
| 101 | CRYPTO_EX_DATA ex_data; | ||
| 102 | int references; | ||
| 103 | int flags; | ||
| 104 | |||
| 105 | /* Normally used to cached montgomery values */ | ||
| 106 | char *method_mod_n; | ||
| 107 | char *method_mod_p; | ||
| 108 | char *method_mod_q; | ||
| 109 | |||
| 110 | BN_BLINDING *blinding; | ||
| 111 | } RSA; | ||
| 112 | |||
| 113 | #define RSA_3 0x3L | ||
| 114 | #define RSA_F4 0x10001L | ||
| 115 | |||
| 116 | #define RSA_METHOD_FLAG_NO_CHECK 0x01 /* don't check pub/private match */ | ||
| 117 | #define RSA_FLAG_CACHE_PUBLIC 0x02 | ||
| 118 | #define RSA_FLAG_CACHE_PRIVATE 0x04 | ||
| 119 | #define RSA_FLAG_BLINDING 0x08 | ||
| 120 | #define RSA_FLAG_THREAD_SAFE 0x10 | ||
| 121 | |||
| 122 | #define RSA_PKCS1_PADDING 1 | ||
| 123 | #define RSA_SSLV23_PADDING 2 | ||
| 124 | #define RSA_NO_PADDING 3 | ||
| 125 | |||
| 126 | #define RSA_set_app_data(s,arg) RSA_set_ex_data(s,0,(char *)arg) | ||
| 127 | #define RSA_get_app_data(s) RSA_get_ex_data(s,0) | ||
| 128 | |||
| 129 | #ifndef NOPROTO | ||
| 130 | RSA * RSA_new(void); | ||
| 131 | RSA * RSA_new_method(RSA_METHOD *method); | ||
| 132 | int RSA_size(RSA *); | ||
| 133 | RSA * RSA_generate_key(int bits, unsigned long e,void | ||
| 134 | (*callback)(int,int,char *),char *cb_arg); | ||
| 135 | /* next 4 return -1 on error */ | ||
| 136 | int RSA_public_encrypt(int flen, unsigned char *from, | ||
| 137 | unsigned char *to, RSA *rsa,int padding); | ||
| 138 | int RSA_private_encrypt(int flen, unsigned char *from, | ||
| 139 | unsigned char *to, RSA *rsa,int padding); | ||
| 140 | int RSA_public_decrypt(int flen, unsigned char *from, | ||
| 141 | unsigned char *to, RSA *rsa,int padding); | ||
| 142 | int RSA_private_decrypt(int flen, unsigned char *from, | ||
| 143 | unsigned char *to, RSA *rsa,int padding); | ||
| 144 | void RSA_free (RSA *r); | ||
| 145 | |||
| 146 | int RSA_flags(RSA *r); | ||
| 147 | |||
| 148 | void RSA_set_default_method(RSA_METHOD *meth); | ||
| 149 | |||
| 150 | /* If you have RSAref compiled in. */ | ||
| 151 | RSA_METHOD *RSA_PKCS1_RSAref(void); | ||
| 152 | |||
| 153 | /* these are the actual SSLeay RSA functions */ | ||
| 154 | RSA_METHOD *RSA_PKCS1_SSLeay(void); | ||
| 155 | |||
| 156 | void ERR_load_RSA_strings(void ); | ||
| 157 | |||
| 158 | RSA * d2i_RSAPublicKey(RSA **a, unsigned char **pp, long length); | ||
| 159 | int i2d_RSAPublicKey(RSA *a, unsigned char **pp); | ||
| 160 | RSA * d2i_RSAPrivateKey(RSA **a, unsigned char **pp, long length); | ||
| 161 | int i2d_RSAPrivateKey(RSA *a, unsigned char **pp); | ||
| 162 | #ifndef NO_FP_API | ||
| 163 | int RSA_print_fp(FILE *fp, RSA *r,int offset); | ||
| 164 | #endif | ||
| 165 | |||
| 166 | #ifdef HEADER_BIO_H | ||
| 167 | int RSA_print(BIO *bp, RSA *r,int offset); | ||
| 168 | #endif | ||
| 169 | |||
| 170 | int i2d_Netscape_RSA(RSA *a, unsigned char **pp, int (*cb)()); | ||
| 171 | RSA *d2i_Netscape_RSA(RSA **a, unsigned char **pp, long length, int (*cb)()); | ||
| 172 | /* Naughty internal function required elsewhere, to handle a MS structure | ||
| 173 | * that is the same as the netscape one :-) */ | ||
| 174 | RSA *d2i_Netscape_RSA_2(RSA **a, unsigned char **pp, long length, int (*cb)()); | ||
| 175 | |||
| 176 | /* The following 2 functions sign and verify a X509_SIG ASN1 object | ||
| 177 | * inside PKCS#1 padded RSA encryption */ | ||
| 178 | int RSA_sign(int type, unsigned char *m, unsigned int m_len, | ||
| 179 | unsigned char *sigret, unsigned int *siglen, RSA *rsa); | ||
| 180 | int RSA_verify(int type, unsigned char *m, unsigned int m_len, | ||
| 181 | unsigned char *sigbuf, unsigned int siglen, RSA *rsa); | ||
| 182 | |||
| 183 | /* The following 2 function sign and verify a ASN1_OCTET_STRING | ||
| 184 | * object inside PKCS#1 padded RSA encryption */ | ||
| 185 | int RSA_sign_ASN1_OCTET_STRING(int type, unsigned char *m, unsigned int m_len, | ||
| 186 | unsigned char *sigret, unsigned int *siglen, RSA *rsa); | ||
| 187 | int RSA_verify_ASN1_OCTET_STRING(int type, unsigned char *m, unsigned int m_len, | ||
| 188 | unsigned char *sigbuf, unsigned int siglen, RSA *rsa); | ||
| 189 | |||
| 190 | int RSA_blinding_on(RSA *rsa, BN_CTX *ctx); | ||
| 191 | void RSA_blinding_off(RSA *rsa); | ||
| 192 | |||
| 193 | int RSA_padding_add_PKCS1_type_1(unsigned char *to,int tlen, | ||
| 194 | unsigned char *f,int fl); | ||
| 195 | int RSA_padding_check_PKCS1_type_1(unsigned char *to,int tlen, | ||
| 196 | unsigned char *f,int fl); | ||
| 197 | int RSA_padding_add_PKCS1_type_2(unsigned char *to,int tlen, | ||
| 198 | unsigned char *f,int fl); | ||
| 199 | int RSA_padding_check_PKCS1_type_2(unsigned char *to,int tlen, | ||
| 200 | unsigned char *f,int fl); | ||
| 201 | int RSA_padding_add_SSLv23(unsigned char *to,int tlen, | ||
| 202 | unsigned char *f,int fl); | ||
| 203 | int RSA_padding_check_SSLv23(unsigned char *to,int tlen, | ||
| 204 | unsigned char *f,int fl); | ||
| 205 | int RSA_padding_add_none(unsigned char *to,int tlen, | ||
| 206 | unsigned char *f,int fl); | ||
| 207 | int RSA_padding_check_none(unsigned char *to,int tlen, | ||
| 208 | unsigned char *f,int fl); | ||
| 209 | |||
| 210 | int RSA_get_ex_new_index(long argl, char *argp, int (*new_func)(), | ||
| 211 | int (*dup_func)(), void (*free_func)()); | ||
| 212 | int RSA_set_ex_data(RSA *r,int idx,char *arg); | ||
| 213 | char *RSA_get_ex_data(RSA *r, int idx); | ||
| 214 | |||
| 215 | #else | ||
| 216 | |||
| 217 | RSA * RSA_new(); | ||
| 218 | RSA * RSA_new_method(); | ||
| 219 | int RSA_size(); | ||
| 220 | RSA * RSA_generate_key(); | ||
| 221 | int RSA_public_encrypt(); | ||
| 222 | int RSA_private_encrypt(); | ||
| 223 | int RSA_public_decrypt(); | ||
| 224 | int RSA_private_decrypt(); | ||
| 225 | void RSA_free (); | ||
| 226 | |||
| 227 | int RSA_flags(); | ||
| 228 | |||
| 229 | void RSA_set_default_method(); | ||
| 230 | |||
| 231 | /* RSA_METHOD *RSA_PKCS1_RSAref(); */ | ||
| 232 | RSA_METHOD *RSA_PKCS1_SSLeay(); | ||
| 233 | |||
| 234 | void ERR_load_RSA_strings(); | ||
| 235 | |||
| 236 | RSA * d2i_RSAPublicKey(); | ||
| 237 | int i2d_RSAPublicKey(); | ||
| 238 | RSA * d2i_RSAPrivateKey(); | ||
| 239 | int i2d_RSAPrivateKey(); | ||
| 240 | #ifndef NO_FP_API | ||
| 241 | int RSA_print_fp(); | ||
| 242 | #endif | ||
| 243 | |||
| 244 | int RSA_print(); | ||
| 245 | |||
| 246 | int i2d_Netscape_RSA(); | ||
| 247 | RSA *d2i_Netscape_RSA(); | ||
| 248 | RSA *d2i_Netscape_RSA_2(); | ||
| 249 | |||
| 250 | int RSA_sign(); | ||
| 251 | int RSA_verify(); | ||
| 252 | |||
| 253 | int RSA_sign_ASN1_OCTET_STRING(); | ||
| 254 | int RSA_verify_ASN1_OCTET_STRING(); | ||
| 255 | int RSA_blinding_on(); | ||
| 256 | void RSA_blinding_off(); | ||
| 257 | |||
| 258 | int RSA_padding_add_PKCS1_type_1(); | ||
| 259 | int RSA_padding_check_PKCS1_type_1(); | ||
| 260 | int RSA_padding_add_PKCS1_type_2(); | ||
| 261 | int RSA_padding_check_PKCS1_type_2(); | ||
| 262 | int RSA_padding_add_SSLv23(); | ||
| 263 | int RSA_padding_check_SSLv23(); | ||
| 264 | int RSA_padding_add_none(); | ||
| 265 | int RSA_padding_check_none(); | ||
| 266 | |||
| 267 | int RSA_get_ex_new_index(); | ||
| 268 | int RSA_set_ex_data(); | ||
| 269 | char *RSA_get_ex_data(); | ||
| 270 | |||
| 271 | #endif | ||
| 272 | |||
| 273 | /* BEGIN ERROR CODES */ | ||
| 274 | /* Error codes for the RSA functions. */ | ||
| 275 | |||
| 276 | /* Function codes. */ | ||
| 277 | #define RSA_F_RSA_EAY_PRIVATE_DECRYPT 100 | ||
| 278 | #define RSA_F_RSA_EAY_PRIVATE_ENCRYPT 101 | ||
| 279 | #define RSA_F_RSA_EAY_PUBLIC_DECRYPT 102 | ||
| 280 | #define RSA_F_RSA_EAY_PUBLIC_ENCRYPT 103 | ||
| 281 | #define RSA_F_RSA_GENERATE_KEY 104 | ||
| 282 | #define RSA_F_RSA_NEW_METHOD 105 | ||
| 283 | #define RSA_F_RSA_PADDING_ADD_NONE 106 | ||
| 284 | #define RSA_F_RSA_PADDING_ADD_PKCS1_TYPE_1 107 | ||
| 285 | #define RSA_F_RSA_PADDING_ADD_PKCS1_TYPE_2 108 | ||
| 286 | #define RSA_F_RSA_PADDING_ADD_SSLV23 109 | ||
| 287 | #define RSA_F_RSA_PADDING_CHECK_NONE 110 | ||
| 288 | #define RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_1 111 | ||
| 289 | #define RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_2 112 | ||
| 290 | #define RSA_F_RSA_PADDING_CHECK_SSLV23 113 | ||
| 291 | #define RSA_F_RSA_PRINT 114 | ||
| 292 | #define RSA_F_RSA_PRINT_FP 115 | ||
| 293 | #define RSA_F_RSA_SIGN 116 | ||
| 294 | #define RSA_F_RSA_SIGN_ASN1_OCTET_STRING 117 | ||
| 295 | #define RSA_F_RSA_VERIFY 118 | ||
| 296 | #define RSA_F_RSA_VERIFY_ASN1_OCTET_STRING 119 | ||
| 297 | |||
| 298 | /* Reason codes. */ | ||
| 299 | #define RSA_R_ALGORITHM_MISMATCH 100 | ||
| 300 | #define RSA_R_BAD_E_VALUE 101 | ||
| 301 | #define RSA_R_BAD_FIXED_HEADER_DECRYPT 102 | ||
| 302 | #define RSA_R_BAD_PAD_BYTE_COUNT 103 | ||
| 303 | #define RSA_R_BAD_SIGNATURE 104 | ||
| 304 | #define RSA_R_BAD_ZERO_BYTE 105 | ||
| 305 | #define RSA_R_BLOCK_TYPE_IS_NOT_01 106 | ||
| 306 | #define RSA_R_BLOCK_TYPE_IS_NOT_02 107 | ||
| 307 | #define RSA_R_DATA_GREATER_THAN_MOD_LEN 108 | ||
| 308 | #define RSA_R_DATA_TOO_LARGE 109 | ||
| 309 | #define RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE 110 | ||
| 310 | #define RSA_R_DATA_TOO_SMALL 111 | ||
| 311 | #define RSA_R_DIGEST_TOO_BIG_FOR_RSA_KEY 112 | ||
| 312 | #define RSA_R_NULL_BEFORE_BLOCK_MISSING 113 | ||
| 313 | #define RSA_R_PADDING_CHECK_FAILED 114 | ||
| 314 | #define RSA_R_SSLV3_ROLLBACK_ATTACK 115 | ||
| 315 | #define RSA_R_THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD 116 | ||
| 316 | #define RSA_R_UNKNOWN_ALGORITHM_TYPE 117 | ||
| 317 | #define RSA_R_UNKNOWN_PADDING_TYPE 118 | ||
| 318 | #define RSA_R_WRONG_SIGNATURE_LENGTH 119 | ||
| 319 | |||
| 320 | #ifdef __cplusplus | ||
| 321 | } | ||
| 322 | #endif | ||
| 323 | #endif | ||
| 324 | |||
diff --git a/src/lib/libcrypto/rsa/rsa_eay.c b/src/lib/libcrypto/rsa/rsa_eay.c new file mode 100644 index 0000000000..42a77f11cd --- /dev/null +++ b/src/lib/libcrypto/rsa/rsa_eay.c | |||
| @@ -0,0 +1,274 @@ | |||
| 1 | |||
| 2 | /* This file has been explicitly broken by ryker for OpenBSD, July | ||
| 3 | * 1, 1998. In spite of the title, there is no implementation of the | ||
| 4 | * RSA algorithm left in this file. All these routines will return an | ||
| 5 | * error and fail when called. They exist as stubs and can be | ||
| 6 | * ressurected from the bit bucket by someone in the free world once | ||
| 7 | * the RSA algorithm is no longer subject to patent problems. Eric | ||
| 8 | * Young's original copyright is below. | ||
| 9 | */ | ||
| 10 | |||
| 11 | /* crypto/rsa/rsa_eay.c */ | ||
| 12 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 13 | * All rights reserved. | ||
| 14 | * | ||
| 15 | * This package is an SSL implementation written | ||
| 16 | * by Eric Young (eay@cryptsoft.com). | ||
| 17 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 18 | * | ||
| 19 | * This library is free for commercial and non-commercial use as long as | ||
| 20 | * the following conditions are aheared to. The following conditions | ||
| 21 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 22 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 23 | * included with this distribution is covered by the same copyright terms | ||
| 24 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 25 | * | ||
| 26 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 27 | * the code are not to be removed. | ||
| 28 | * If this package is used in a product, Eric Young should be given attribution | ||
| 29 | * as the author of the parts of the library used. | ||
| 30 | * This can be in the form of a textual message at program startup or | ||
| 31 | * in documentation (online or textual) provided with the package. | ||
| 32 | * | ||
| 33 | * Redistribution and use in source and binary forms, with or without | ||
| 34 | * modification, are permitted provided that the following conditions | ||
| 35 | * are met: | ||
| 36 | * 1. Redistributions of source code must retain the copyright | ||
| 37 | * notice, this list of conditions and the following disclaimer. | ||
| 38 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 39 | * notice, this list of conditions and the following disclaimer in the | ||
| 40 | * documentation and/or other materials provided with the distribution. | ||
| 41 | * 3. All advertising materials mentioning features or use of this software | ||
| 42 | * must display the following acknowledgement: | ||
| 43 | * "This product includes cryptographic software written by | ||
| 44 | * Eric Young (eay@cryptsoft.com)" | ||
| 45 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 46 | * being used are not cryptographic related :-). | ||
| 47 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 48 | * the apps directory (application code) you must include an acknowledgement: | ||
| 49 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 50 | * | ||
| 51 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 52 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 53 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 54 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 55 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 56 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 57 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 58 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 59 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 60 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 61 | * SUCH DAMAGE. | ||
| 62 | * | ||
| 63 | * The licence and distribution terms for any publically available version or | ||
| 64 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 65 | * copied and put under another distribution licence | ||
| 66 | * [including the GNU Public Licence.] | ||
| 67 | */ | ||
| 68 | |||
| 69 | #include <stdio.h> | ||
| 70 | #include "cryptlib.h" | ||
| 71 | #include "bn.h" | ||
| 72 | #include "rsa.h" | ||
| 73 | #include "rand.h" | ||
| 74 | |||
| 75 | #ifndef NOPROTO | ||
| 76 | static int RSA_eay_public_encrypt(int flen, unsigned char *from, | ||
| 77 | unsigned char *to, RSA *rsa,int padding); | ||
| 78 | static int RSA_eay_private_encrypt(int flen, unsigned char *from, | ||
| 79 | unsigned char *to, RSA *rsa,int padding); | ||
| 80 | static int RSA_eay_public_decrypt(int flen, unsigned char *from, | ||
| 81 | unsigned char *to, RSA *rsa,int padding); | ||
| 82 | static int RSA_eay_private_decrypt(int flen, unsigned char *from, | ||
| 83 | unsigned char *to, RSA *rsa,int padding); | ||
| 84 | static int RSA_eay_mod_exp(BIGNUM *r0, BIGNUM *i, RSA *rsa); | ||
| 85 | static int RSA_eay_init(RSA *rsa); | ||
| 86 | static int RSA_eay_finish(RSA *rsa); | ||
| 87 | #else | ||
| 88 | static int RSA_eay_public_encrypt(); | ||
| 89 | static int RSA_eay_private_encrypt(); | ||
| 90 | static int RSA_eay_public_decrypt(); | ||
| 91 | static int RSA_eay_private_decrypt(); | ||
| 92 | static int RSA_eay_mod_exp(); | ||
| 93 | static int RSA_eay_init(); | ||
| 94 | static int RSA_eay_finish(); | ||
| 95 | #endif | ||
| 96 | |||
| 97 | static RSA_METHOD rsa_pkcs1_eay_meth={ | ||
| 98 | "Eric Young's PKCS#1 RSA", | ||
| 99 | RSA_eay_public_encrypt, | ||
| 100 | RSA_eay_public_decrypt, | ||
| 101 | RSA_eay_private_encrypt, | ||
| 102 | RSA_eay_private_decrypt, | ||
| 103 | RSA_eay_mod_exp, | ||
| 104 | BN_mod_exp_mont, | ||
| 105 | RSA_eay_init, | ||
| 106 | RSA_eay_finish, | ||
| 107 | 0, | ||
| 108 | NULL, | ||
| 109 | }; | ||
| 110 | |||
| 111 | RSA_METHOD *RSA_PKCS1_SSLeay() | ||
| 112 | { | ||
| 113 | return(&rsa_pkcs1_eay_meth); | ||
| 114 | } | ||
| 115 | |||
| 116 | static int RSA_eay_public_encrypt(flen, from, to, rsa, padding) | ||
| 117 | int flen; | ||
| 118 | unsigned char *from; | ||
| 119 | unsigned char *to; | ||
| 120 | RSA *rsa; | ||
| 121 | int padding; | ||
| 122 | { | ||
| 123 | BIGNUM *f=NULL,*ret=NULL; | ||
| 124 | int i,j,k,num=0,r= -1; | ||
| 125 | unsigned char *buf=NULL; | ||
| 126 | BN_CTX *ctx=NULL; | ||
| 127 | |||
| 128 | /* Body of this routine removed for OpenBSD - will return | ||
| 129 | * when the RSA patent expires | ||
| 130 | */ | ||
| 131 | |||
| 132 | err: | ||
| 133 | if (ctx != NULL) BN_CTX_free(ctx); | ||
| 134 | if (f != NULL) BN_free(f); | ||
| 135 | if (ret != NULL) BN_free(ret); | ||
| 136 | if (buf != NULL) | ||
| 137 | { | ||
| 138 | memset(buf,0,num); | ||
| 139 | Free(buf); | ||
| 140 | } | ||
| 141 | return(r); | ||
| 142 | } | ||
| 143 | |||
| 144 | static int RSA_eay_private_encrypt(flen, from, to, rsa, padding) | ||
| 145 | int flen; | ||
| 146 | unsigned char *from; | ||
| 147 | unsigned char *to; | ||
| 148 | RSA *rsa; | ||
| 149 | int padding; | ||
| 150 | { | ||
| 151 | BIGNUM *f=NULL,*ret=NULL; | ||
| 152 | int i,j,k,num=0,r= -1; | ||
| 153 | unsigned char *buf=NULL; | ||
| 154 | BN_CTX *ctx=NULL; | ||
| 155 | |||
| 156 | /* Body of this routine removed for OpenBSD - will return | ||
| 157 | * when the RSA patent expires | ||
| 158 | */ | ||
| 159 | |||
| 160 | err: | ||
| 161 | if (ctx != NULL) BN_CTX_free(ctx); | ||
| 162 | if (ret != NULL) BN_free(ret); | ||
| 163 | if (f != NULL) BN_free(f); | ||
| 164 | if (buf != NULL) | ||
| 165 | { | ||
| 166 | memset(buf,0,num); | ||
| 167 | Free(buf); | ||
| 168 | } | ||
| 169 | return(r); | ||
| 170 | } | ||
| 171 | |||
| 172 | static int RSA_eay_private_decrypt(flen, from, to, rsa,padding) | ||
| 173 | int flen; | ||
| 174 | unsigned char *from; | ||
| 175 | unsigned char *to; | ||
| 176 | RSA *rsa; | ||
| 177 | int padding; | ||
| 178 | { | ||
| 179 | BIGNUM *f=NULL,*ret=NULL; | ||
| 180 | int j,num=0,r= -1; | ||
| 181 | unsigned char *p; | ||
| 182 | unsigned char *buf=NULL; | ||
| 183 | BN_CTX *ctx=NULL; | ||
| 184 | |||
| 185 | /* Body of this routine removed for OpenBSD - will return | ||
| 186 | * when the RSA patent expires | ||
| 187 | */ | ||
| 188 | |||
| 189 | err: | ||
| 190 | if (ctx != NULL) BN_CTX_free(ctx); | ||
| 191 | if (f != NULL) BN_free(f); | ||
| 192 | if (ret != NULL) BN_free(ret); | ||
| 193 | if (buf != NULL) | ||
| 194 | { | ||
| 195 | memset(buf,0,num); | ||
| 196 | Free(buf); | ||
| 197 | } | ||
| 198 | return(r); | ||
| 199 | } | ||
| 200 | |||
| 201 | static int RSA_eay_public_decrypt(flen, from, to, rsa, padding) | ||
| 202 | int flen; | ||
| 203 | unsigned char *from; | ||
| 204 | unsigned char *to; | ||
| 205 | RSA *rsa; | ||
| 206 | int padding; | ||
| 207 | { | ||
| 208 | BIGNUM *f=NULL,*ret=NULL; | ||
| 209 | int i,num=0,r= -1; | ||
| 210 | unsigned char *p; | ||
| 211 | unsigned char *buf=NULL; | ||
| 212 | BN_CTX *ctx=NULL; | ||
| 213 | |||
| 214 | |||
| 215 | /* Body of this routine removed for OpenBSD - will return | ||
| 216 | * when the RSA patent expires | ||
| 217 | */ | ||
| 218 | |||
| 219 | err: | ||
| 220 | if (ctx != NULL) BN_CTX_free(ctx); | ||
| 221 | if (f != NULL) BN_free(f); | ||
| 222 | if (ret != NULL) BN_free(ret); | ||
| 223 | if (buf != NULL) | ||
| 224 | { | ||
| 225 | memset(buf,0,num); | ||
| 226 | Free(buf); | ||
| 227 | } | ||
| 228 | return(r); | ||
| 229 | } | ||
| 230 | |||
| 231 | static int RSA_eay_mod_exp(r0, I, rsa) | ||
| 232 | BIGNUM *r0; | ||
| 233 | BIGNUM *I; | ||
| 234 | RSA *rsa; | ||
| 235 | { | ||
| 236 | BIGNUM *r1=NULL,*m1=NULL; | ||
| 237 | int ret=0; | ||
| 238 | BN_CTX *ctx; | ||
| 239 | |||
| 240 | if ((ctx=BN_CTX_new()) == NULL) goto err; | ||
| 241 | m1=BN_new(); | ||
| 242 | r1=BN_new(); | ||
| 243 | if ((m1 == NULL) || (r1 == NULL)) goto err; | ||
| 244 | |||
| 245 | /* Body of this routine removed for OpenBSD - will return | ||
| 246 | * when the RSA patent expires | ||
| 247 | */ | ||
| 248 | err: | ||
| 249 | if (m1 != NULL) BN_free(m1); | ||
| 250 | if (r1 != NULL) BN_free(r1); | ||
| 251 | BN_CTX_free(ctx); | ||
| 252 | return(ret); | ||
| 253 | } | ||
| 254 | |||
| 255 | static int RSA_eay_init(rsa) | ||
| 256 | RSA *rsa; | ||
| 257 | { | ||
| 258 | rsa->flags|=RSA_FLAG_CACHE_PUBLIC|RSA_FLAG_CACHE_PRIVATE; | ||
| 259 | return(1); | ||
| 260 | } | ||
| 261 | |||
| 262 | static int RSA_eay_finish(rsa) | ||
| 263 | RSA *rsa; | ||
| 264 | { | ||
| 265 | if (rsa->method_mod_n != NULL) | ||
| 266 | BN_MONT_CTX_free((BN_MONT_CTX *)rsa->method_mod_n); | ||
| 267 | if (rsa->method_mod_p != NULL) | ||
| 268 | BN_MONT_CTX_free((BN_MONT_CTX *)rsa->method_mod_p); | ||
| 269 | if (rsa->method_mod_q != NULL) | ||
| 270 | BN_MONT_CTX_free((BN_MONT_CTX *)rsa->method_mod_q); | ||
| 271 | return(1); | ||
| 272 | } | ||
| 273 | |||
| 274 | |||
diff --git a/src/lib/libcrypto/rsa/rsa_err.c b/src/lib/libcrypto/rsa/rsa_err.c new file mode 100644 index 0000000000..796b3afd47 --- /dev/null +++ b/src/lib/libcrypto/rsa/rsa_err.c | |||
| @@ -0,0 +1,129 @@ | |||
| 1 | /* lib/rsa/rsa_err.c */ | ||
| 2 | /* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | #include <stdio.h> | ||
| 59 | #include "err.h" | ||
| 60 | #include "rsa.h" | ||
| 61 | |||
| 62 | /* BEGIN ERROR CODES */ | ||
| 63 | #ifndef NO_ERR | ||
| 64 | static ERR_STRING_DATA RSA_str_functs[]= | ||
| 65 | { | ||
| 66 | {ERR_PACK(0,RSA_F_RSA_EAY_PRIVATE_DECRYPT,0), "RSA_EAY_PRIVATE_DECRYPT"}, | ||
| 67 | {ERR_PACK(0,RSA_F_RSA_EAY_PRIVATE_ENCRYPT,0), "RSA_EAY_PRIVATE_ENCRYPT"}, | ||
| 68 | {ERR_PACK(0,RSA_F_RSA_EAY_PUBLIC_DECRYPT,0), "RSA_EAY_PUBLIC_DECRYPT"}, | ||
| 69 | {ERR_PACK(0,RSA_F_RSA_EAY_PUBLIC_ENCRYPT,0), "RSA_EAY_PUBLIC_ENCRYPT"}, | ||
| 70 | {ERR_PACK(0,RSA_F_RSA_GENERATE_KEY,0), "RSA_generate_key"}, | ||
| 71 | {ERR_PACK(0,RSA_F_RSA_NEW_METHOD,0), "RSA_new_method"}, | ||
| 72 | {ERR_PACK(0,RSA_F_RSA_PADDING_ADD_NONE,0), "RSA_padding_add_none"}, | ||
| 73 | {ERR_PACK(0,RSA_F_RSA_PADDING_ADD_PKCS1_TYPE_1,0), "RSA_padding_add_PKCS1_type_1"}, | ||
| 74 | {ERR_PACK(0,RSA_F_RSA_PADDING_ADD_PKCS1_TYPE_2,0), "RSA_padding_add_PKCS1_type_2"}, | ||
| 75 | {ERR_PACK(0,RSA_F_RSA_PADDING_ADD_SSLV23,0), "RSA_padding_add_SSLv23"}, | ||
| 76 | {ERR_PACK(0,RSA_F_RSA_PADDING_CHECK_NONE,0), "RSA_padding_check_none"}, | ||
| 77 | {ERR_PACK(0,RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_1,0), "RSA_padding_check_PKCS1_type_1"}, | ||
| 78 | {ERR_PACK(0,RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_2,0), "RSA_padding_check_PKCS1_type_2"}, | ||
| 79 | {ERR_PACK(0,RSA_F_RSA_PADDING_CHECK_SSLV23,0), "RSA_padding_check_SSLv23"}, | ||
| 80 | {ERR_PACK(0,RSA_F_RSA_PRINT,0), "RSA_print"}, | ||
| 81 | {ERR_PACK(0,RSA_F_RSA_PRINT_FP,0), "RSA_print_fp"}, | ||
| 82 | {ERR_PACK(0,RSA_F_RSA_SIGN,0), "RSA_sign"}, | ||
| 83 | {ERR_PACK(0,RSA_F_RSA_SIGN_ASN1_OCTET_STRING,0), "RSA_sign_ASN1_OCTET_STRING"}, | ||
| 84 | {ERR_PACK(0,RSA_F_RSA_VERIFY,0), "RSA_verify"}, | ||
| 85 | {ERR_PACK(0,RSA_F_RSA_VERIFY_ASN1_OCTET_STRING,0), "RSA_verify_ASN1_OCTET_STRING"}, | ||
| 86 | {0,NULL}, | ||
| 87 | }; | ||
| 88 | |||
| 89 | static ERR_STRING_DATA RSA_str_reasons[]= | ||
| 90 | { | ||
| 91 | {RSA_R_ALGORITHM_MISMATCH ,"algorithm mismatch"}, | ||
| 92 | {RSA_R_BAD_E_VALUE ,"bad e value"}, | ||
| 93 | {RSA_R_BAD_FIXED_HEADER_DECRYPT ,"bad fixed header decrypt"}, | ||
| 94 | {RSA_R_BAD_PAD_BYTE_COUNT ,"bad pad byte count"}, | ||
| 95 | {RSA_R_BAD_SIGNATURE ,"bad signature"}, | ||
| 96 | {RSA_R_BAD_ZERO_BYTE ,"bad zero byte"}, | ||
| 97 | {RSA_R_BLOCK_TYPE_IS_NOT_01 ,"block type is not 01"}, | ||
| 98 | {RSA_R_BLOCK_TYPE_IS_NOT_02 ,"block type is not 02"}, | ||
| 99 | {RSA_R_DATA_GREATER_THAN_MOD_LEN ,"data greater than mod len"}, | ||
| 100 | {RSA_R_DATA_TOO_LARGE ,"data too large"}, | ||
| 101 | {RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE ,"data too large for key size"}, | ||
| 102 | {RSA_R_DATA_TOO_SMALL ,"data too small"}, | ||
| 103 | {RSA_R_DIGEST_TOO_BIG_FOR_RSA_KEY ,"digest too big for rsa key"}, | ||
| 104 | {RSA_R_NULL_BEFORE_BLOCK_MISSING ,"null before block missing"}, | ||
| 105 | {RSA_R_PADDING_CHECK_FAILED ,"padding check failed"}, | ||
| 106 | {RSA_R_SSLV3_ROLLBACK_ATTACK ,"sslv3 rollback attack"}, | ||
| 107 | {RSA_R_THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD,"the asn1 object identifier is not known for this md"}, | ||
| 108 | {RSA_R_UNKNOWN_ALGORITHM_TYPE ,"unknown algorithm type"}, | ||
| 109 | {RSA_R_UNKNOWN_PADDING_TYPE ,"unknown padding type"}, | ||
| 110 | {RSA_R_WRONG_SIGNATURE_LENGTH ,"wrong signature length"}, | ||
| 111 | {0,NULL}, | ||
| 112 | }; | ||
| 113 | |||
| 114 | #endif | ||
| 115 | |||
| 116 | void ERR_load_RSA_strings() | ||
| 117 | { | ||
| 118 | static int init=1; | ||
| 119 | |||
| 120 | if (init); | ||
| 121 | {; | ||
| 122 | init=0; | ||
| 123 | #ifndef NO_ERR | ||
| 124 | ERR_load_strings(ERR_LIB_RSA,RSA_str_functs); | ||
| 125 | ERR_load_strings(ERR_LIB_RSA,RSA_str_reasons); | ||
| 126 | #endif | ||
| 127 | |||
| 128 | } | ||
| 129 | } | ||
diff --git a/src/lib/libcrypto/rsa/rsa_gen.c b/src/lib/libcrypto/rsa/rsa_gen.c new file mode 100644 index 0000000000..4cbd373829 --- /dev/null +++ b/src/lib/libcrypto/rsa/rsa_gen.c | |||
| @@ -0,0 +1,101 @@ | |||
| 1 | /* crypto/rsa/rsa_gen.c */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | #include <time.h> | ||
| 61 | #include "cryptlib.h" | ||
| 62 | #include "bn.h" | ||
| 63 | #include "rsa.h" | ||
| 64 | |||
| 65 | RSA *RSA_generate_key(bits, e_value, callback,cb_arg) | ||
| 66 | int bits; | ||
| 67 | unsigned long e_value; | ||
| 68 | void (*callback)(P_I_I_P); | ||
| 69 | char *cb_arg; | ||
| 70 | { | ||
| 71 | RSA *rsa=NULL; | ||
| 72 | BIGNUM *r0=NULL,*r1=NULL,*r2=NULL,*r3=NULL,*tmp; | ||
| 73 | int bitsp,bitsq,ok= -1,n=0; | ||
| 74 | BN_CTX *ctx=NULL,*ctx2=NULL; | ||
| 75 | |||
| 76 | ctx=BN_CTX_new(); | ||
| 77 | if (ctx == NULL) goto err; | ||
| 78 | ctx2=BN_CTX_new(); | ||
| 79 | if (ctx2 == NULL) goto err; | ||
| 80 | |||
| 81 | /* Body of this routine removed for OpenBSD - will return | ||
| 82 | * when the RSA patent expires | ||
| 83 | */ | ||
| 84 | err: | ||
| 85 | if (ok == -1) | ||
| 86 | { | ||
| 87 | RSAerr(RSA_F_RSA_GENERATE_KEY,ERR_LIB_BN); | ||
| 88 | ok=0; | ||
| 89 | } | ||
| 90 | BN_CTX_free(ctx); | ||
| 91 | BN_CTX_free(ctx2); | ||
| 92 | |||
| 93 | if (!ok) | ||
| 94 | { | ||
| 95 | if (rsa != NULL) RSA_free(rsa); | ||
| 96 | return(NULL); | ||
| 97 | } | ||
| 98 | else | ||
| 99 | return(rsa); | ||
| 100 | } | ||
| 101 | |||
diff --git a/src/lib/libcrypto/rsa/rsa_lib.c b/src/lib/libcrypto/rsa/rsa_lib.c new file mode 100644 index 0000000000..95a56f8a28 --- /dev/null +++ b/src/lib/libcrypto/rsa/rsa_lib.c | |||
| @@ -0,0 +1,294 @@ | |||
| 1 | /* crypto/rsa/rsa_lib.c */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | #include "crypto.h" | ||
| 61 | #include "cryptlib.h" | ||
| 62 | #include "lhash.h" | ||
| 63 | #include "bn.h" | ||
| 64 | #include "rsa.h" | ||
| 65 | |||
| 66 | char *RSA_version="RSA part of SSLeay 0.9.0b 29-Jun-1998"; | ||
| 67 | |||
| 68 | static RSA_METHOD *default_RSA_meth=NULL; | ||
| 69 | static int rsa_meth_num=0; | ||
| 70 | static STACK *rsa_meth=NULL; | ||
| 71 | |||
| 72 | RSA *RSA_new() | ||
| 73 | { | ||
| 74 | return(RSA_new_method(NULL)); | ||
| 75 | } | ||
| 76 | |||
| 77 | void RSA_set_default_method(meth) | ||
| 78 | RSA_METHOD *meth; | ||
| 79 | { | ||
| 80 | default_RSA_meth=meth; | ||
| 81 | } | ||
| 82 | |||
| 83 | RSA *RSA_new_method(meth) | ||
| 84 | RSA_METHOD *meth; | ||
| 85 | { | ||
| 86 | RSA *ret; | ||
| 87 | |||
| 88 | if (default_RSA_meth == NULL) | ||
| 89 | { | ||
| 90 | #ifdef RSAref | ||
| 91 | default_RSA_meth=RSA_PKCS1_RSAref(); | ||
| 92 | #else | ||
| 93 | default_RSA_meth=RSA_PKCS1_SSLeay(); | ||
| 94 | #endif | ||
| 95 | } | ||
| 96 | ret=(RSA *)Malloc(sizeof(RSA)); | ||
| 97 | if (ret == NULL) | ||
| 98 | { | ||
| 99 | RSAerr(RSA_F_RSA_NEW_METHOD,ERR_R_MALLOC_FAILURE); | ||
| 100 | return(NULL); | ||
| 101 | } | ||
| 102 | |||
| 103 | if (meth == NULL) | ||
| 104 | ret->meth=default_RSA_meth; | ||
| 105 | else | ||
| 106 | ret->meth=meth; | ||
| 107 | |||
| 108 | ret->pad=0; | ||
| 109 | ret->version=0; | ||
| 110 | ret->n=NULL; | ||
| 111 | ret->e=NULL; | ||
| 112 | ret->d=NULL; | ||
| 113 | ret->p=NULL; | ||
| 114 | ret->q=NULL; | ||
| 115 | ret->dmp1=NULL; | ||
| 116 | ret->dmq1=NULL; | ||
| 117 | ret->iqmp=NULL; | ||
| 118 | ret->references=1; | ||
| 119 | ret->method_mod_n=NULL; | ||
| 120 | ret->method_mod_p=NULL; | ||
| 121 | ret->method_mod_q=NULL; | ||
| 122 | ret->blinding=NULL; | ||
| 123 | ret->flags=ret->meth->flags; | ||
| 124 | if ((ret->meth->init != NULL) && !ret->meth->init(ret)) | ||
| 125 | { | ||
| 126 | Free(ret); | ||
| 127 | ret=NULL; | ||
| 128 | } | ||
| 129 | CRYPTO_new_ex_data(rsa_meth,(char *)ret,&ret->ex_data); | ||
| 130 | return(ret); | ||
| 131 | } | ||
| 132 | |||
| 133 | void RSA_free(r) | ||
| 134 | RSA *r; | ||
| 135 | { | ||
| 136 | int i; | ||
| 137 | |||
| 138 | if (r == NULL) return; | ||
| 139 | |||
| 140 | i=CRYPTO_add(&r->references,-1,CRYPTO_LOCK_RSA); | ||
| 141 | #ifdef REF_PRINT | ||
| 142 | REF_PRINT("RSA",r); | ||
| 143 | #endif | ||
| 144 | if (i > 0) return; | ||
| 145 | #ifdef REF_CHECK | ||
| 146 | if (i < 0) | ||
| 147 | { | ||
| 148 | fprintf(stderr,"RSA_free, bad reference count\n"); | ||
| 149 | abort(); | ||
| 150 | } | ||
| 151 | #endif | ||
| 152 | |||
| 153 | CRYPTO_free_ex_data(rsa_meth,(char *)r,&r->ex_data); | ||
| 154 | |||
| 155 | if (r->meth->finish != NULL) | ||
| 156 | r->meth->finish(r); | ||
| 157 | |||
| 158 | if (r->n != NULL) BN_clear_free(r->n); | ||
| 159 | if (r->e != NULL) BN_clear_free(r->e); | ||
| 160 | if (r->d != NULL) BN_clear_free(r->d); | ||
| 161 | if (r->p != NULL) BN_clear_free(r->p); | ||
| 162 | if (r->q != NULL) BN_clear_free(r->q); | ||
| 163 | if (r->dmp1 != NULL) BN_clear_free(r->dmp1); | ||
| 164 | if (r->dmq1 != NULL) BN_clear_free(r->dmq1); | ||
| 165 | if (r->iqmp != NULL) BN_clear_free(r->iqmp); | ||
| 166 | if (r->blinding != NULL) BN_BLINDING_free(r->blinding); | ||
| 167 | Free(r); | ||
| 168 | } | ||
| 169 | |||
| 170 | int RSA_get_ex_new_index(argl,argp,new_func,dup_func,free_func) | ||
| 171 | long argl; | ||
| 172 | char *argp; | ||
| 173 | int (*new_func)(); | ||
| 174 | int (*dup_func)(); | ||
| 175 | void (*free_func)(); | ||
| 176 | { | ||
| 177 | rsa_meth_num++; | ||
| 178 | return(CRYPTO_get_ex_new_index(rsa_meth_num-1, | ||
| 179 | &rsa_meth,argl,argp,new_func,dup_func,free_func)); | ||
| 180 | } | ||
| 181 | |||
| 182 | int RSA_set_ex_data(r,idx,arg) | ||
| 183 | RSA *r; | ||
| 184 | int idx; | ||
| 185 | char *arg; | ||
| 186 | { | ||
| 187 | return(CRYPTO_set_ex_data(&r->ex_data,idx,arg)); | ||
| 188 | } | ||
| 189 | |||
| 190 | char *RSA_get_ex_data(r,idx) | ||
| 191 | RSA *r; | ||
| 192 | int idx; | ||
| 193 | { | ||
| 194 | return(CRYPTO_get_ex_data(&r->ex_data,idx)); | ||
| 195 | } | ||
| 196 | |||
| 197 | int RSA_size(r) | ||
| 198 | RSA *r; | ||
| 199 | { | ||
| 200 | return(BN_num_bytes(r->n)); | ||
| 201 | } | ||
| 202 | |||
| 203 | int RSA_public_encrypt(flen, from, to, rsa, padding) | ||
| 204 | int flen; | ||
| 205 | unsigned char *from; | ||
| 206 | unsigned char *to; | ||
| 207 | RSA *rsa; | ||
| 208 | int padding; | ||
| 209 | { | ||
| 210 | return(rsa->meth->rsa_pub_enc(flen, from, to, rsa, padding)); | ||
| 211 | } | ||
| 212 | |||
| 213 | int RSA_private_encrypt(flen, from, to, rsa, padding) | ||
| 214 | int flen; | ||
| 215 | unsigned char *from; | ||
| 216 | unsigned char *to; | ||
| 217 | RSA *rsa; | ||
| 218 | int padding; | ||
| 219 | { | ||
| 220 | return(rsa->meth->rsa_priv_enc(flen, from, to, rsa, padding)); | ||
| 221 | } | ||
| 222 | |||
| 223 | int RSA_private_decrypt(flen, from, to, rsa, padding) | ||
| 224 | int flen; | ||
| 225 | unsigned char *from; | ||
| 226 | unsigned char *to; | ||
| 227 | RSA *rsa; | ||
| 228 | int padding; | ||
| 229 | { | ||
| 230 | return(rsa->meth->rsa_priv_dec(flen, from, to, rsa, padding)); | ||
| 231 | } | ||
| 232 | |||
| 233 | int RSA_public_decrypt(flen, from, to, rsa, padding) | ||
| 234 | int flen; | ||
| 235 | unsigned char *from; | ||
| 236 | unsigned char *to; | ||
| 237 | RSA *rsa; | ||
| 238 | int padding; | ||
| 239 | { | ||
| 240 | return(rsa->meth->rsa_pub_dec(flen, from, to, rsa, padding)); | ||
| 241 | } | ||
| 242 | |||
| 243 | int RSA_flags(r) | ||
| 244 | RSA *r; | ||
| 245 | { | ||
| 246 | return((r == NULL)?0:r->meth->flags); | ||
| 247 | } | ||
| 248 | |||
| 249 | void RSA_blinding_off(rsa) | ||
| 250 | RSA *rsa; | ||
| 251 | { | ||
| 252 | if (rsa->blinding != NULL) | ||
| 253 | { | ||
| 254 | BN_BLINDING_free(rsa->blinding); | ||
| 255 | rsa->blinding=NULL; | ||
| 256 | } | ||
| 257 | rsa->flags&= ~RSA_FLAG_BLINDING; | ||
| 258 | } | ||
| 259 | |||
| 260 | int RSA_blinding_on(rsa,p_ctx) | ||
| 261 | RSA *rsa; | ||
| 262 | BN_CTX *p_ctx; | ||
| 263 | { | ||
| 264 | BIGNUM *A,*Ai; | ||
| 265 | BN_CTX *ctx; | ||
| 266 | int ret=0; | ||
| 267 | |||
| 268 | if (p_ctx == NULL) | ||
| 269 | { | ||
| 270 | if ((ctx=BN_CTX_new()) == NULL) goto err; | ||
| 271 | } | ||
| 272 | else | ||
| 273 | ctx=p_ctx; | ||
| 274 | |||
| 275 | if (rsa->blinding != NULL) | ||
| 276 | BN_BLINDING_free(rsa->blinding); | ||
| 277 | |||
| 278 | A=ctx->bn[0]; | ||
| 279 | ctx->tos++; | ||
| 280 | if (!BN_rand(A,BN_num_bits(rsa->n)-1,1,0)) goto err; | ||
| 281 | if ((Ai=BN_mod_inverse(A,rsa->n,ctx)) == NULL) goto err; | ||
| 282 | |||
| 283 | if (!rsa->meth->bn_mod_exp(A,A,rsa->e,rsa->n,ctx, | ||
| 284 | (char *)rsa->method_mod_n)) goto err; | ||
| 285 | rsa->blinding=BN_BLINDING_new(A,Ai,rsa->n); | ||
| 286 | ctx->tos--; | ||
| 287 | rsa->flags|=RSA_FLAG_BLINDING; | ||
| 288 | BN_free(Ai); | ||
| 289 | ret=1; | ||
| 290 | err: | ||
| 291 | if (ctx != p_ctx) BN_CTX_free(ctx); | ||
| 292 | return(ret); | ||
| 293 | } | ||
| 294 | |||
diff --git a/src/lib/libcrypto/rsa/rsa_none.c b/src/lib/libcrypto/rsa/rsa_none.c new file mode 100644 index 0000000000..f0dd943657 --- /dev/null +++ b/src/lib/libcrypto/rsa/rsa_none.c | |||
| @@ -0,0 +1,109 @@ | |||
| 1 | /* crypto/rsa/rsa_none.c */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | #include "cryptlib.h" | ||
| 61 | #include "bn.h" | ||
| 62 | #include "rsa.h" | ||
| 63 | #include "rand.h" | ||
| 64 | |||
| 65 | int RSA_padding_add_none(to,tlen,from,flen) | ||
| 66 | unsigned char *to; | ||
| 67 | int tlen; | ||
| 68 | unsigned char *from; | ||
| 69 | int flen; | ||
| 70 | { | ||
| 71 | if (flen >= tlen) | ||
| 72 | { | ||
| 73 | RSAerr(RSA_F_RSA_PADDING_ADD_NONE,RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE); | ||
| 74 | return(0); | ||
| 75 | } | ||
| 76 | |||
| 77 | *(to++)=0; | ||
| 78 | memcpy(to,from,(unsigned int)flen); | ||
| 79 | return(1); | ||
| 80 | } | ||
| 81 | |||
| 82 | int RSA_padding_check_none(to,tlen,from,flen) | ||
| 83 | unsigned char *to; | ||
| 84 | int tlen; | ||
| 85 | unsigned char *from; | ||
| 86 | int flen; | ||
| 87 | { | ||
| 88 | int j; | ||
| 89 | |||
| 90 | from++; | ||
| 91 | if (flen+1 > tlen) | ||
| 92 | { | ||
| 93 | RSAerr(RSA_F_RSA_PADDING_CHECK_NONE,RSA_R_DATA_TOO_LARGE); | ||
| 94 | return(-1); | ||
| 95 | } | ||
| 96 | if (*(from++) != 0) | ||
| 97 | { | ||
| 98 | RSAerr(RSA_F_RSA_PADDING_CHECK_NONE,RSA_R_BAD_ZERO_BYTE); | ||
| 99 | return(-1); | ||
| 100 | } | ||
| 101 | |||
| 102 | /* scan over padding data */ | ||
| 103 | j=flen-1; /* one for type and one for the prepended 0. */ | ||
| 104 | memset(to,0,tlen-j); | ||
| 105 | to+=(tlen-j); | ||
| 106 | memcpy(to,from,j); | ||
| 107 | return(j); | ||
| 108 | } | ||
| 109 | |||
diff --git a/src/lib/libcrypto/rsa/rsa_pk1.c b/src/lib/libcrypto/rsa/rsa_pk1.c new file mode 100644 index 0000000000..2791291b94 --- /dev/null +++ b/src/lib/libcrypto/rsa/rsa_pk1.c | |||
| @@ -0,0 +1,233 @@ | |||
| 1 | /* crypto/rsa/rsa_pk1.c */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | #include "cryptlib.h" | ||
| 61 | #include "bn.h" | ||
| 62 | #include "rsa.h" | ||
| 63 | #include "rand.h" | ||
| 64 | |||
| 65 | #ifndef NOPROTO | ||
| 66 | int RSA_padding_add_PKCS1_type_1(); | ||
| 67 | int RSA_padding_check_PKCS1_type_1(); | ||
| 68 | int RSA_padding_add_PKCS1_type_2(); | ||
| 69 | int RSA_padding_check_PKCS1_type_2(); | ||
| 70 | int RSA_padding_add_SSLv23(); | ||
| 71 | int RSA_padding_check_SSLv23(); | ||
| 72 | int RSA_padding_add_none(); | ||
| 73 | int RSA_padding_check_none(); | ||
| 74 | |||
| 75 | #endif | ||
| 76 | |||
| 77 | int RSA_padding_add_PKCS1_type_1(to,tlen,from,flen) | ||
| 78 | unsigned char *to; | ||
| 79 | int tlen; | ||
| 80 | unsigned char *from; | ||
| 81 | int flen; | ||
| 82 | { | ||
| 83 | int j; | ||
| 84 | unsigned char *p; | ||
| 85 | |||
| 86 | if (flen > (tlen-11)) | ||
| 87 | { | ||
| 88 | RSAerr(RSA_F_RSA_PADDING_ADD_PKCS1_TYPE_1,RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE); | ||
| 89 | return(0); | ||
| 90 | } | ||
| 91 | |||
| 92 | p=(unsigned char *)to; | ||
| 93 | |||
| 94 | *(p++)=0; | ||
| 95 | *(p++)=1; /* Private Key BT (Block Type) */ | ||
| 96 | |||
| 97 | /* padd out with 0xff data */ | ||
| 98 | j=tlen-3-flen; | ||
| 99 | memset(p,0xff,j); | ||
| 100 | p+=j; | ||
| 101 | *(p++)='\0'; | ||
| 102 | memcpy(p,from,(unsigned int)flen); | ||
| 103 | return(1); | ||
| 104 | } | ||
| 105 | |||
| 106 | int RSA_padding_check_PKCS1_type_1(to,tlen,from,flen) | ||
| 107 | unsigned char *to; | ||
| 108 | int tlen; | ||
| 109 | unsigned char *from; | ||
| 110 | int flen; | ||
| 111 | { | ||
| 112 | int i,j; | ||
| 113 | unsigned char *p; | ||
| 114 | |||
| 115 | p=from; | ||
| 116 | if (*(p++) != 01) | ||
| 117 | { | ||
| 118 | RSAerr(RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_1,RSA_R_BLOCK_TYPE_IS_NOT_01); | ||
| 119 | return(-1); | ||
| 120 | } | ||
| 121 | |||
| 122 | /* scan over padding data */ | ||
| 123 | j=flen-1; /* one for type. */ | ||
| 124 | for (i=0; i<j; i++) | ||
| 125 | { | ||
| 126 | if (*p != 0xff) /* should decrypt to 0xff */ | ||
| 127 | { | ||
| 128 | if (*p == 0) | ||
| 129 | { p++; break; } | ||
| 130 | else { | ||
| 131 | RSAerr(RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_1,RSA_R_BAD_FIXED_HEADER_DECRYPT); | ||
| 132 | return(-1); | ||
| 133 | } | ||
| 134 | } | ||
| 135 | p++; | ||
| 136 | } | ||
| 137 | |||
| 138 | if (i == j) | ||
| 139 | { | ||
| 140 | RSAerr(RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_1,RSA_R_NULL_BEFORE_BLOCK_MISSING); | ||
| 141 | return(-1); | ||
| 142 | } | ||
| 143 | |||
| 144 | if (i < 8) | ||
| 145 | { | ||
| 146 | RSAerr(RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_1,RSA_R_BAD_PAD_BYTE_COUNT); | ||
| 147 | return(-1); | ||
| 148 | } | ||
| 149 | i++; /* Skip over the '\0' */ | ||
| 150 | j-=i; | ||
| 151 | memcpy(to,p,(unsigned int)j); | ||
| 152 | |||
| 153 | return(j); | ||
| 154 | } | ||
| 155 | |||
| 156 | int RSA_padding_add_PKCS1_type_2(to,tlen,from,flen) | ||
| 157 | unsigned char *to; | ||
| 158 | int tlen; | ||
| 159 | unsigned char *from; | ||
| 160 | int flen; | ||
| 161 | { | ||
| 162 | int i,j; | ||
| 163 | unsigned char *p; | ||
| 164 | |||
| 165 | if (flen > (tlen-11)) | ||
| 166 | { | ||
| 167 | RSAerr(RSA_F_RSA_PADDING_ADD_PKCS1_TYPE_2,RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE); | ||
| 168 | return(0); | ||
| 169 | } | ||
| 170 | |||
| 171 | p=(unsigned char *)to; | ||
| 172 | |||
| 173 | *(p++)=0; | ||
| 174 | *(p++)=2; /* Public Key BT (Block Type) */ | ||
| 175 | |||
| 176 | /* pad out with non-zero random data */ | ||
| 177 | j=tlen-3-flen; | ||
| 178 | |||
| 179 | RAND_bytes(p,j); | ||
| 180 | for (i=0; i<j; i++) | ||
| 181 | { | ||
| 182 | if (*p == '\0') | ||
| 183 | do { | ||
| 184 | RAND_bytes(p,1); | ||
| 185 | } while (*p == '\0'); | ||
| 186 | p++; | ||
| 187 | } | ||
| 188 | |||
| 189 | *(p++)='\0'; | ||
| 190 | |||
| 191 | memcpy(p,from,(unsigned int)flen); | ||
| 192 | return(1); | ||
| 193 | } | ||
| 194 | |||
| 195 | int RSA_padding_check_PKCS1_type_2(to,tlen,from,flen) | ||
| 196 | unsigned char *to; | ||
| 197 | int tlen; | ||
| 198 | unsigned char *from; | ||
| 199 | int flen; | ||
| 200 | { | ||
| 201 | int i,j; | ||
| 202 | unsigned char *p; | ||
| 203 | |||
| 204 | p=from; | ||
| 205 | if (*(p++) != 02) | ||
| 206 | { | ||
| 207 | RSAerr(RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_2,RSA_R_BLOCK_TYPE_IS_NOT_02); | ||
| 208 | return(-1); | ||
| 209 | } | ||
| 210 | |||
| 211 | /* scan over padding data */ | ||
| 212 | j=flen-1; /* one for type. */ | ||
| 213 | for (i=0; i<j; i++) | ||
| 214 | if (*(p++) == 0) break; | ||
| 215 | |||
| 216 | if (i == j) | ||
| 217 | { | ||
| 218 | RSAerr(RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_2,RSA_R_NULL_BEFORE_BLOCK_MISSING); | ||
| 219 | return(-1); | ||
| 220 | } | ||
| 221 | |||
| 222 | if (i < 8) | ||
| 223 | { | ||
| 224 | RSAerr(RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_2,RSA_R_BAD_PAD_BYTE_COUNT); | ||
| 225 | return(-1); | ||
| 226 | } | ||
| 227 | i++; /* Skip over the '\0' */ | ||
| 228 | j-=i; | ||
| 229 | memcpy(to,p,(unsigned int)j); | ||
| 230 | |||
| 231 | return(j); | ||
| 232 | } | ||
| 233 | |||
diff --git a/src/lib/libcrypto/rsa/rsa_saos.c b/src/lib/libcrypto/rsa/rsa_saos.c new file mode 100644 index 0000000000..fb0fae5a43 --- /dev/null +++ b/src/lib/libcrypto/rsa/rsa_saos.c | |||
| @@ -0,0 +1,153 @@ | |||
| 1 | /* crypto/rsa/rsa_saos.c */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | #include "cryptlib.h" | ||
| 61 | #include "bn.h" | ||
| 62 | #include "rsa.h" | ||
| 63 | #include "objects.h" | ||
| 64 | #include "x509.h" | ||
| 65 | |||
| 66 | int RSA_sign_ASN1_OCTET_STRING(type,m,m_len,sigret,siglen,rsa) | ||
| 67 | int type; | ||
| 68 | unsigned char *m; | ||
| 69 | unsigned int m_len; | ||
| 70 | unsigned char *sigret; | ||
| 71 | unsigned int *siglen; | ||
| 72 | RSA *rsa; | ||
| 73 | { | ||
| 74 | ASN1_OCTET_STRING sig; | ||
| 75 | int i,j,ret=1; | ||
| 76 | unsigned char *p,*s; | ||
| 77 | |||
| 78 | sig.type=V_ASN1_OCTET_STRING; | ||
| 79 | sig.length=m_len; | ||
| 80 | sig.data=m; | ||
| 81 | |||
| 82 | i=i2d_ASN1_OCTET_STRING(&sig,NULL); | ||
| 83 | j=RSA_size(rsa); | ||
| 84 | if ((i-RSA_PKCS1_PADDING) > j) | ||
| 85 | { | ||
| 86 | RSAerr(RSA_F_RSA_SIGN_ASN1_OCTET_STRING,RSA_R_DIGEST_TOO_BIG_FOR_RSA_KEY); | ||
| 87 | return(0); | ||
| 88 | } | ||
| 89 | s=(unsigned char *)Malloc((unsigned int)j+1); | ||
| 90 | if (s == NULL) | ||
| 91 | { | ||
| 92 | RSAerr(RSA_F_RSA_SIGN_ASN1_OCTET_STRING,ERR_R_MALLOC_FAILURE); | ||
| 93 | return(0); | ||
| 94 | } | ||
| 95 | p=s; | ||
| 96 | i2d_ASN1_OCTET_STRING(&sig,&p); | ||
| 97 | i=RSA_private_encrypt(i,s,sigret,rsa,RSA_PKCS1_PADDING); | ||
| 98 | if (i <= 0) | ||
| 99 | ret=0; | ||
| 100 | else | ||
| 101 | *siglen=i; | ||
| 102 | |||
| 103 | memset(s,0,(unsigned int)j+1); | ||
| 104 | Free(s); | ||
| 105 | return(ret); | ||
| 106 | } | ||
| 107 | |||
| 108 | int RSA_verify_ASN1_OCTET_STRING(dtype, m, m_len, sigbuf, siglen, rsa) | ||
| 109 | int dtype; | ||
| 110 | unsigned char *m; | ||
| 111 | unsigned int m_len; | ||
| 112 | unsigned char *sigbuf; | ||
| 113 | unsigned int siglen; | ||
| 114 | RSA *rsa; | ||
| 115 | { | ||
| 116 | int i,ret=0; | ||
| 117 | unsigned char *p,*s; | ||
| 118 | ASN1_OCTET_STRING *sig=NULL; | ||
| 119 | |||
| 120 | if (siglen != (unsigned int)RSA_size(rsa)) | ||
| 121 | { | ||
| 122 | RSAerr(RSA_F_RSA_VERIFY_ASN1_OCTET_STRING,RSA_R_WRONG_SIGNATURE_LENGTH); | ||
| 123 | return(0); | ||
| 124 | } | ||
| 125 | |||
| 126 | s=(unsigned char *)Malloc((unsigned int)siglen); | ||
| 127 | if (s == NULL) | ||
| 128 | { | ||
| 129 | RSAerr(RSA_F_RSA_VERIFY_ASN1_OCTET_STRING,ERR_R_MALLOC_FAILURE); | ||
| 130 | goto err; | ||
| 131 | } | ||
| 132 | i=RSA_public_decrypt((int)siglen,sigbuf,s,rsa,RSA_PKCS1_PADDING); | ||
| 133 | |||
| 134 | if (i <= 0) goto err; | ||
| 135 | |||
| 136 | p=s; | ||
| 137 | sig=d2i_ASN1_OCTET_STRING(NULL,&p,(long)i); | ||
| 138 | if (sig == NULL) goto err; | ||
| 139 | |||
| 140 | if ( ((unsigned int)sig->length != m_len) || | ||
| 141 | (memcmp(m,sig->data,m_len) != 0)) | ||
| 142 | { | ||
| 143 | RSAerr(RSA_F_RSA_VERIFY_ASN1_OCTET_STRING,RSA_R_BAD_SIGNATURE); | ||
| 144 | } | ||
| 145 | else | ||
| 146 | ret=1; | ||
| 147 | err: | ||
| 148 | if (sig != NULL) ASN1_OCTET_STRING_free(sig); | ||
| 149 | memset(s,0,(unsigned int)siglen); | ||
| 150 | Free(s); | ||
| 151 | return(ret); | ||
| 152 | } | ||
| 153 | |||
diff --git a/src/lib/libcrypto/rsa/rsa_sign.c b/src/lib/libcrypto/rsa/rsa_sign.c new file mode 100644 index 0000000000..28c5571e74 --- /dev/null +++ b/src/lib/libcrypto/rsa/rsa_sign.c | |||
| @@ -0,0 +1,196 @@ | |||
| 1 | /* crypto/rsa/rsa_sign.c */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | #include "cryptlib.h" | ||
| 61 | #include "bn.h" | ||
| 62 | #include "rsa.h" | ||
| 63 | #include "objects.h" | ||
| 64 | #include "x509.h" | ||
| 65 | |||
| 66 | int RSA_sign(type,m,m_len,sigret,siglen,rsa) | ||
| 67 | int type; | ||
| 68 | unsigned char *m; | ||
| 69 | unsigned int m_len; | ||
| 70 | unsigned char *sigret; | ||
| 71 | unsigned int *siglen; | ||
| 72 | RSA *rsa; | ||
| 73 | { | ||
| 74 | X509_SIG sig; | ||
| 75 | ASN1_TYPE parameter; | ||
| 76 | int i,j,ret=1; | ||
| 77 | unsigned char *p,*s; | ||
| 78 | X509_ALGOR algor; | ||
| 79 | ASN1_OCTET_STRING digest; | ||
| 80 | |||
| 81 | sig.algor= &algor; | ||
| 82 | sig.algor->algorithm=OBJ_nid2obj(type); | ||
| 83 | if (sig.algor->algorithm == NULL) | ||
| 84 | { | ||
| 85 | RSAerr(RSA_F_RSA_SIGN,RSA_R_UNKNOWN_ALGORITHM_TYPE); | ||
| 86 | return(0); | ||
| 87 | } | ||
| 88 | if (sig.algor->algorithm->length == 0) | ||
| 89 | { | ||
| 90 | RSAerr(RSA_F_RSA_SIGN,RSA_R_THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD); | ||
| 91 | return(0); | ||
| 92 | } | ||
| 93 | parameter.type=V_ASN1_NULL; | ||
| 94 | parameter.value.ptr=NULL; | ||
| 95 | sig.algor->parameter= ¶meter; | ||
| 96 | |||
| 97 | sig.digest= &digest; | ||
| 98 | sig.digest->data=m; | ||
| 99 | sig.digest->length=m_len; | ||
| 100 | |||
| 101 | i=i2d_X509_SIG(&sig,NULL); | ||
| 102 | j=RSA_size(rsa); | ||
| 103 | if ((i-RSA_PKCS1_PADDING) > j) | ||
| 104 | { | ||
| 105 | RSAerr(RSA_F_RSA_SIGN,RSA_R_DIGEST_TOO_BIG_FOR_RSA_KEY); | ||
| 106 | return(0); | ||
| 107 | } | ||
| 108 | s=(unsigned char *)Malloc((unsigned int)j+1); | ||
| 109 | if (s == NULL) | ||
| 110 | { | ||
| 111 | RSAerr(RSA_F_RSA_SIGN,ERR_R_MALLOC_FAILURE); | ||
| 112 | return(0); | ||
| 113 | } | ||
| 114 | p=s; | ||
| 115 | i2d_X509_SIG(&sig,&p); | ||
| 116 | i=RSA_private_encrypt(i,s,sigret,rsa,RSA_PKCS1_PADDING); | ||
| 117 | if (i <= 0) | ||
| 118 | ret=0; | ||
| 119 | else | ||
| 120 | *siglen=i; | ||
| 121 | |||
| 122 | memset(s,0,(unsigned int)j+1); | ||
| 123 | Free(s); | ||
| 124 | return(ret); | ||
| 125 | } | ||
| 126 | |||
| 127 | int RSA_verify(dtype, m, m_len, sigbuf, siglen, rsa) | ||
| 128 | int dtype; | ||
| 129 | unsigned char *m; | ||
| 130 | unsigned int m_len; | ||
| 131 | unsigned char *sigbuf; | ||
| 132 | unsigned int siglen; | ||
| 133 | RSA *rsa; | ||
| 134 | { | ||
| 135 | int i,ret=0,sigtype; | ||
| 136 | unsigned char *p,*s; | ||
| 137 | X509_SIG *sig=NULL; | ||
| 138 | |||
| 139 | if (siglen != (unsigned int)RSA_size(rsa)) | ||
| 140 | { | ||
| 141 | RSAerr(RSA_F_RSA_VERIFY,RSA_R_WRONG_SIGNATURE_LENGTH); | ||
| 142 | return(0); | ||
| 143 | } | ||
| 144 | |||
| 145 | s=(unsigned char *)Malloc((unsigned int)siglen); | ||
| 146 | if (s == NULL) | ||
| 147 | { | ||
| 148 | RSAerr(RSA_F_RSA_VERIFY,ERR_R_MALLOC_FAILURE); | ||
| 149 | goto err; | ||
| 150 | } | ||
| 151 | i=RSA_public_decrypt((int)siglen,sigbuf,s,rsa,RSA_PKCS1_PADDING); | ||
| 152 | |||
| 153 | if (i <= 0) goto err; | ||
| 154 | |||
| 155 | p=s; | ||
| 156 | sig=d2i_X509_SIG(NULL,&p,(long)i); | ||
| 157 | if (sig == NULL) goto err; | ||
| 158 | sigtype=OBJ_obj2nid(sig->algor->algorithm); | ||
| 159 | |||
| 160 | #ifdef RSA_DEBUG | ||
| 161 | /* put a backward compatability flag in EAY */ | ||
| 162 | fprintf(stderr,"in(%s) expect(%s)\n",OBJ_nid2ln(sigtype), | ||
| 163 | OBJ_nid2ln(dtype)); | ||
| 164 | #endif | ||
| 165 | if (sigtype != dtype) | ||
| 166 | { | ||
| 167 | if (((dtype == NID_md5) && | ||
| 168 | (sigtype == NID_md5WithRSAEncryption)) || | ||
| 169 | ((dtype == NID_md2) && | ||
| 170 | (sigtype == NID_md2WithRSAEncryption))) | ||
| 171 | { | ||
| 172 | /* ok, we will let it through */ | ||
| 173 | #if !defined(NO_STDIO) && !defined(WIN16) | ||
| 174 | fprintf(stderr,"signature has problems, re-make with post SSLeay045\n"); | ||
| 175 | #endif | ||
| 176 | } | ||
| 177 | else | ||
| 178 | { | ||
| 179 | RSAerr(RSA_F_RSA_VERIFY,RSA_R_ALGORITHM_MISMATCH); | ||
| 180 | goto err; | ||
| 181 | } | ||
| 182 | } | ||
| 183 | if ( ((unsigned int)sig->digest->length != m_len) || | ||
| 184 | (memcmp(m,sig->digest->data,m_len) != 0)) | ||
| 185 | { | ||
| 186 | RSAerr(RSA_F_RSA_VERIFY,RSA_R_BAD_SIGNATURE); | ||
| 187 | } | ||
| 188 | else | ||
| 189 | ret=1; | ||
| 190 | err: | ||
| 191 | if (sig != NULL) X509_SIG_free(sig); | ||
| 192 | memset(s,0,(unsigned int)siglen); | ||
| 193 | Free(s); | ||
| 194 | return(ret); | ||
| 195 | } | ||
| 196 | |||
diff --git a/src/lib/libcrypto/rsa/rsa_ssl.c b/src/lib/libcrypto/rsa/rsa_ssl.c new file mode 100644 index 0000000000..9bcd4b2c03 --- /dev/null +++ b/src/lib/libcrypto/rsa/rsa_ssl.c | |||
| @@ -0,0 +1,153 @@ | |||
| 1 | /* crypto/rsa/rsa_ssl.c */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | #include "cryptlib.h" | ||
| 61 | #include "bn.h" | ||
| 62 | #include "rsa.h" | ||
| 63 | #include "rand.h" | ||
| 64 | |||
| 65 | int RSA_padding_add_SSLv23(to,tlen,from,flen) | ||
| 66 | unsigned char *to; | ||
| 67 | int tlen; | ||
| 68 | unsigned char *from; | ||
| 69 | int flen; | ||
| 70 | { | ||
| 71 | int i,j; | ||
| 72 | unsigned char *p; | ||
| 73 | |||
| 74 | if (flen > (tlen-11)) | ||
| 75 | { | ||
| 76 | RSAerr(RSA_F_RSA_PADDING_ADD_SSLV23,RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE); | ||
| 77 | return(0); | ||
| 78 | } | ||
| 79 | |||
| 80 | p=(unsigned char *)to; | ||
| 81 | |||
| 82 | *(p++)=0; | ||
| 83 | *(p++)=2; /* Public Key BT (Block Type) */ | ||
| 84 | |||
| 85 | /* pad out with non-zero random data */ | ||
| 86 | j=tlen-3-8-flen; | ||
| 87 | |||
| 88 | RAND_bytes(p,j); | ||
| 89 | for (i=0; i<j; i++) | ||
| 90 | { | ||
| 91 | if (*p == '\0') | ||
| 92 | do { | ||
| 93 | RAND_bytes(p,1); | ||
| 94 | } while (*p == '\0'); | ||
| 95 | p++; | ||
| 96 | } | ||
| 97 | |||
| 98 | memset(p,3,8); | ||
| 99 | p+=8; | ||
| 100 | *(p++)='\0'; | ||
| 101 | |||
| 102 | memcpy(p,from,(unsigned int)flen); | ||
| 103 | return(1); | ||
| 104 | } | ||
| 105 | |||
| 106 | int RSA_padding_check_SSLv23(to,tlen,from,flen) | ||
| 107 | unsigned char *to; | ||
| 108 | int tlen; | ||
| 109 | unsigned char *from; | ||
| 110 | int flen; | ||
| 111 | { | ||
| 112 | int i,j,k; | ||
| 113 | unsigned char *p; | ||
| 114 | |||
| 115 | p=from; | ||
| 116 | if (flen < 10) | ||
| 117 | { | ||
| 118 | RSAerr(RSA_F_RSA_PADDING_CHECK_SSLV23,RSA_R_DATA_TOO_SMALL); | ||
| 119 | return(-1); | ||
| 120 | } | ||
| 121 | if (*(p++) != 02) | ||
| 122 | { | ||
| 123 | RSAerr(RSA_F_RSA_PADDING_CHECK_SSLV23,RSA_R_BLOCK_TYPE_IS_NOT_02); | ||
| 124 | return(-1); | ||
| 125 | } | ||
| 126 | |||
| 127 | /* scan over padding data */ | ||
| 128 | j=flen-1; /* one for type */ | ||
| 129 | for (i=0; i<j; i++) | ||
| 130 | if (*(p++) == 0) break; | ||
| 131 | |||
| 132 | if ((i == j) || (i < 8)) | ||
| 133 | { | ||
| 134 | RSAerr(RSA_F_RSA_PADDING_CHECK_SSLV23,RSA_R_NULL_BEFORE_BLOCK_MISSING); | ||
| 135 | return(-1); | ||
| 136 | } | ||
| 137 | for (k= -8; k<0; k++) | ||
| 138 | { | ||
| 139 | if (p[k] != 0x03) break; | ||
| 140 | } | ||
| 141 | if (k == 0) | ||
| 142 | { | ||
| 143 | RSAerr(RSA_F_RSA_PADDING_CHECK_SSLV23,RSA_R_SSLV3_ROLLBACK_ATTACK); | ||
| 144 | return(-1); | ||
| 145 | } | ||
| 146 | |||
| 147 | i++; /* Skip over the '\0' */ | ||
| 148 | j-=i; | ||
| 149 | memcpy(to,p,(unsigned int)j); | ||
| 150 | |||
| 151 | return(j); | ||
| 152 | } | ||
| 153 | |||
