by_dir.c
上传用户:yisoukefu
上传日期:2020-08-09
资源大小:39506k
文件大小:10k
源码类别:

其他游戏

开发平台:

Visual C++

  1. /* crypto/x509/by_dir.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. #include <stdio.h>
  59. #include <time.h>
  60. #include <errno.h>
  61. #include "cryptlib.h"
  62. #ifndef NO_SYS_TYPES_H
  63. # include <sys/types.h>
  64. #endif
  65. #ifdef MAC_OS_pre_X
  66. # include <stat.h>
  67. #else
  68. # include <sys/stat.h>
  69. #endif
  70. #include <openssl/lhash.h>
  71. #include <openssl/x509.h>
  72. typedef struct lookup_dir_st
  73. {
  74. BUF_MEM *buffer;
  75. int num_dirs;
  76. char **dirs;
  77. int *dirs_type;
  78. int num_dirs_alloced;
  79. } BY_DIR;
  80. static int dir_ctrl(X509_LOOKUP *ctx, int cmd, const char *argp, long argl,
  81. char **ret);
  82. static int new_dir(X509_LOOKUP *lu);
  83. static void free_dir(X509_LOOKUP *lu);
  84. static int add_cert_dir(BY_DIR *ctx,const char *dir,int type);
  85. static int get_cert_by_subject(X509_LOOKUP *xl,int type,X509_NAME *name,
  86. X509_OBJECT *ret);
  87. X509_LOOKUP_METHOD x509_dir_lookup=
  88. {
  89. "Load certs from files in a directory",
  90. new_dir, /* new */
  91. free_dir, /* free */
  92. NULL,  /* init */
  93. NULL, /* shutdown */
  94. dir_ctrl, /* ctrl */
  95. get_cert_by_subject, /* get_by_subject */
  96. NULL, /* get_by_issuer_serial */
  97. NULL, /* get_by_fingerprint */
  98. NULL, /* get_by_alias */
  99. };
  100. X509_LOOKUP_METHOD *X509_LOOKUP_hash_dir(void)
  101. {
  102. return(&x509_dir_lookup);
  103. }
  104. static int dir_ctrl(X509_LOOKUP *ctx, int cmd, const char *argp, long argl,
  105.      char **retp)
  106. {
  107. int ret=0;
  108. BY_DIR *ld;
  109. char *dir = NULL;
  110. ld=(BY_DIR *)ctx->method_data;
  111. switch (cmd)
  112. {
  113. case X509_L_ADD_DIR:
  114. if (argl == X509_FILETYPE_DEFAULT)
  115. {
  116. dir=(char *)Getenv(X509_get_default_cert_dir_env());
  117. if (dir)
  118. ret=add_cert_dir(ld,dir,X509_FILETYPE_PEM);
  119. else
  120. ret=add_cert_dir(ld,X509_get_default_cert_dir(),
  121. X509_FILETYPE_PEM);
  122. if (!ret)
  123. {
  124. X509err(X509_F_DIR_CTRL,X509_R_LOADING_CERT_DIR);
  125. }
  126. }
  127. else
  128. ret=add_cert_dir(ld,argp,(int)argl);
  129. break;
  130. }
  131. return(ret);
  132. }
  133. static int new_dir(X509_LOOKUP *lu)
  134. {
  135. BY_DIR *a;
  136. if ((a=(BY_DIR *)OPENSSL_malloc(sizeof(BY_DIR))) == NULL)
  137. return(0);
  138. if ((a->buffer=BUF_MEM_new()) == NULL)
  139. {
  140. OPENSSL_free(a);
  141. return(0);
  142. }
  143. a->num_dirs=0;
  144. a->dirs=NULL;
  145. a->dirs_type=NULL;
  146. a->num_dirs_alloced=0;
  147. lu->method_data=(char *)a;
  148. return(1);
  149. }
  150. static void free_dir(X509_LOOKUP *lu)
  151. {
  152. BY_DIR *a;
  153. int i;
  154. a=(BY_DIR *)lu->method_data;
  155. for (i=0; i<a->num_dirs; i++)
  156. if (a->dirs[i] != NULL) OPENSSL_free(a->dirs[i]);
  157. if (a->dirs != NULL) OPENSSL_free(a->dirs);
  158. if (a->dirs_type != NULL) OPENSSL_free(a->dirs_type);
  159. if (a->buffer != NULL) BUF_MEM_free(a->buffer);
  160. OPENSSL_free(a);
  161. }
  162. static int add_cert_dir(BY_DIR *ctx, const char *dir, int type)
  163. {
  164. int j,len;
  165. int *ip;
  166. const char *s,*ss,*p;
  167. char **pp;
  168. if (dir == NULL || !*dir)
  169.     {
  170.     X509err(X509_F_ADD_CERT_DIR,X509_R_INVALID_DIRECTORY);
  171.     return 0;
  172.     }
  173. s=dir;
  174. p=s;
  175. for (;;)
  176. {
  177. if ((*p == LIST_SEPARATOR_CHAR) || (*p == ''))
  178. {
  179. ss=s;
  180. s=p+1;
  181. len=(int)(p-ss);
  182. if (len == 0) continue;
  183. for (j=0; j<ctx->num_dirs; j++)
  184. if (strncmp(ctx->dirs[j],ss,(unsigned int)len) == 0)
  185. continue;
  186. if (ctx->num_dirs_alloced < (ctx->num_dirs+1))
  187. {
  188. ctx->num_dirs_alloced+=10;
  189. pp=(char **)OPENSSL_malloc(ctx->num_dirs_alloced*
  190. sizeof(char *));
  191. ip=(int *)OPENSSL_malloc(ctx->num_dirs_alloced*
  192. sizeof(int));
  193. if ((pp == NULL) || (ip == NULL))
  194. {
  195. X509err(X509_F_ADD_CERT_DIR,ERR_R_MALLOC_FAILURE);
  196. return(0);
  197. }
  198. memcpy(pp,ctx->dirs,(ctx->num_dirs_alloced-10)*
  199. sizeof(char *));
  200. memcpy(ip,ctx->dirs_type,(ctx->num_dirs_alloced-10)*
  201. sizeof(int));
  202. if (ctx->dirs != NULL)
  203. OPENSSL_free(ctx->dirs);
  204. if (ctx->dirs_type != NULL)
  205. OPENSSL_free(ctx->dirs_type);
  206. ctx->dirs=pp;
  207. ctx->dirs_type=ip;
  208. }
  209. ctx->dirs_type[ctx->num_dirs]=type;
  210. ctx->dirs[ctx->num_dirs]=(char *)OPENSSL_malloc((unsigned int)len+1);
  211. if (ctx->dirs[ctx->num_dirs] == NULL) return(0);
  212. strncpy(ctx->dirs[ctx->num_dirs],ss,(unsigned int)len);
  213. ctx->dirs[ctx->num_dirs][len]='';
  214. ctx->num_dirs++;
  215. }
  216. if (*p == '') break;
  217. p++;
  218. }
  219. return(1);
  220. }
  221. static int get_cert_by_subject(X509_LOOKUP *xl, int type, X509_NAME *name,
  222.      X509_OBJECT *ret)
  223. {
  224. BY_DIR *ctx;
  225. union {
  226. struct {
  227. X509 st_x509;
  228. X509_CINF st_x509_cinf;
  229. } x509;
  230. struct {
  231. X509_CRL st_crl;
  232. X509_CRL_INFO st_crl_info;
  233. } crl;
  234. } data;
  235. int ok=0;
  236. int i,j,k;
  237. unsigned long h;
  238. BUF_MEM *b=NULL;
  239. struct stat st;
  240. X509_OBJECT stmp,*tmp;
  241. const char *postfix="";
  242. if (name == NULL) return(0);
  243. stmp.type=type;
  244. if (type == X509_LU_X509)
  245. {
  246. data.x509.st_x509.cert_info= &data.x509.st_x509_cinf;
  247. data.x509.st_x509_cinf.subject=name;
  248. stmp.data.x509= &data.x509.st_x509;
  249. postfix="";
  250. }
  251. else if (type == X509_LU_CRL)
  252. {
  253. data.crl.st_crl.crl= &data.crl.st_crl_info;
  254. data.crl.st_crl_info.issuer=name;
  255. stmp.data.crl= &data.crl.st_crl;
  256. postfix="r";
  257. }
  258. else
  259. {
  260. X509err(X509_F_GET_CERT_BY_SUBJECT,X509_R_WRONG_LOOKUP_TYPE);
  261. goto finish;
  262. }
  263. if ((b=BUF_MEM_new()) == NULL)
  264. {
  265. X509err(X509_F_GET_CERT_BY_SUBJECT,ERR_R_BUF_LIB);
  266. goto finish;
  267. }
  268. ctx=(BY_DIR *)xl->method_data;
  269. h=X509_NAME_hash(name);
  270. for (i=0; i<ctx->num_dirs; i++)
  271. {
  272. j=strlen(ctx->dirs[i])+1+8+6+1+1;
  273. if (!BUF_MEM_grow(b,j))
  274. {
  275. X509err(X509_F_GET_CERT_BY_SUBJECT,ERR_R_MALLOC_FAILURE);
  276. goto finish;
  277. }
  278. k=0;
  279. for (;;)
  280. {
  281. char c = '/';
  282. #ifdef OPENSSL_SYS_VMS
  283. c = ctx->dirs[i][strlen(ctx->dirs[i])-1];
  284. if (c != ':' && c != '>' && c != ']')
  285. {
  286. /* If no separator is present, we assume the
  287.    directory specifier is a logical name, and
  288.    add a colon.  We really should use better
  289.    VMS routines for merging things like this,
  290.    but this will do for now...
  291.    -- Richard Levitte */
  292. c = ':';
  293. }
  294. else
  295. {
  296. c = '';
  297. }
  298. #endif
  299. if (c == '')
  300. {
  301. /* This is special.  When c == '', no
  302.    directory separator should be added. */
  303. BIO_snprintf(b->data,b->max,
  304. "%s%08lx.%s%d",ctx->dirs[i],h,
  305. postfix,k);
  306. }
  307. else
  308. {
  309. BIO_snprintf(b->data,b->max,
  310. "%s%c%08lx.%s%d",ctx->dirs[i],c,h,
  311. postfix,k);
  312. }
  313. k++;
  314. if (stat(b->data,&st) < 0)
  315. break;
  316. /* found one. */
  317. if (type == X509_LU_X509)
  318. {
  319. if ((X509_load_cert_file(xl,b->data,
  320. ctx->dirs_type[i])) == 0)
  321. break;
  322. }
  323. else if (type == X509_LU_CRL)
  324. {
  325. if ((X509_load_crl_file(xl,b->data,
  326. ctx->dirs_type[i])) == 0)
  327. break;
  328. }
  329. /* else case will caught higher up */
  330. }
  331. /* we have added it to the cache so now pull
  332.  * it out again */
  333. CRYPTO_r_lock(CRYPTO_LOCK_X509_STORE);
  334. j = sk_X509_OBJECT_find(xl->store_ctx->objs,&stmp);
  335. if(j != -1) tmp=sk_X509_OBJECT_value(xl->store_ctx->objs,j);
  336. else tmp = NULL;
  337. CRYPTO_r_unlock(CRYPTO_LOCK_X509_STORE);
  338. if (tmp != NULL)
  339. {
  340. ok=1;
  341. ret->type=tmp->type;
  342. memcpy(&ret->data,&tmp->data,sizeof(ret->data));
  343. /* If we were going to up the reference count,
  344.  * we would need to do it on a perl 'type'
  345.  * basis */
  346. /* CRYPTO_add(&tmp->data.x509->references,1,
  347. CRYPTO_LOCK_X509);*/
  348. goto finish;
  349. }
  350. }
  351. finish:
  352. if (b != NULL) BUF_MEM_free(b);
  353. return(ok);
  354. }