# kio Library API Documentation

Overview | Class Hierarchy | Classes | Classes (annotated) | Members | Namespaces | Source Files

# kopenssl.h

    00001 /* This file is part of the KDE libraries
    00002    Copyright (C) 2001-2003 George Staikos <staikos@kde.org>
    00003
    00004    This library is free software; you can redistribute it and/or
    00005    modify it under the terms of the GNU Library General Public
    00006    License version 2 as published by the Free Software Foundation.
    00007
    00008    This library is distributed in the hope that it will be useful,
    00009    but WITHOUT ANY WARRANTY; without even the implied warranty of
    00010    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    00011    Library General Public License for more details.
    00012
    00013    You should have received a copy of the GNU Library General Public License
    00014    along with this library; see the file COPYING.LIB.  If not, write to
    00015    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    00016    Boston, MA 02111-1307, USA.
    00017 */
    00018
    00019
    00020 // IF YOU ARE USING THIS CLASS, YOU ARE MAKING A MISTAKE.
    00021
    00022 #ifndef __KOPENSSLPROXY_H
    00023 #define __KOPENSSLPROXY_H
    00024
    00025 #define KOSSL KOpenSSLProxy
    00026 class KOpenSSLProxyPrivate;
    00027
    00028 #include <klibloader.h>
    00029
    00030 #ifdef Q_WS_WIN
    00031 #include "ksslconfig_win.h"
    00032 #else
    00033 #include "ksslconfig.h"
    00034 #endif
    00035
    00036 #ifdef KSSL_HAVE_SSL
    00037 #define crypt _openssl_crypt
    00038 #include <openssl/ssl.h>
    00039 #include <openssl/x509.h>
    00040 #include <openssl/x509v3.h>
    00041 #include <openssl/pem.h>
    00042 #include <openssl/bio.h>
    00043 #include <openssl/rand.h>
    00044 #include <openssl/asn1.h>
    00045 #include <openssl/pkcs7.h>
    00046 #include <openssl/pkcs12.h>
    00047 #include <openssl/evp.h>
    00048 #include <openssl/stack.h>
    00049 #include <openssl/bn.h>
    00050 #undef crypt
    00051 #endif
    00052
    00053 #include <kstaticdeleter.h>
    00054
    00063 class KIO_EXPORT KOpenSSLProxy {
    00064 friend class KStaticDeleter<KOpenSSLProxy>;
    00065 public:
    00066
    00071    static KOpenSSLProxy *self();
    00072
    00076    bool hasLibCrypto() const;
    00077
    00081    bool hasLibSSL() const;
    00082
    00087    void destroy();
    00088
    00089    // Here are the symbols that we need.
    00090 #ifdef KSSL_HAVE_SSL
    00091
    00092    /*
    00093     *   SSL_connect - initiate the TLS/SSL handshake with an TLS/SSL server
    00094     */
    00095    int SSL_connect(SSL *ssl);
    00096
    00097    /*
    00098     *   SSL_accept - initiate the TLS/SSL handshake with an TLS/SSL server
    00099     */
    00100    int SSL_accept(SSL *ssl);
    00101
    00102    /*
    00103     *   SSL_get_error - get the error code
    00104     */
    00105    int SSL_get_error(SSL *ssl, int rc);
    00106
    00107    /*
    00108     *   SSL_read - read bytes from a TLS/SSL connection.
    00109     */
    00110    int SSL_read(SSL *ssl, void *buf, int num);
    00111
    00112    /*
    00113     *   SSL_write - write bytes to a TLS/SSL connection.
    00114     */
    00115    int SSL_write(SSL *ssl, const void *buf, int num);
    00116
    00117    /*
    00118     *   SSL_new - create a new SSL structure for a connection
    00119     */
    00120    SSL *SSL_new(SSL_CTX *ctx);
    00121
    00122    /*
    00123     *   SSL_free - free an allocated SSL structure
    00124     */
    00125    void SSL_free(SSL *ssl);
    00126
    00127    /*
    00128     *   SSL_shutdown - shutdown an allocated SSL connection
    00129     */
    00130    int SSL_shutdown(SSL *ssl);
    00131
    00132    /*
    00133     *   SSL_CTX_new - create a new SSL_CTX object as framework for TLS/SSL enabled functions
    00134     */
    00135    SSL_CTX *SSL_CTX_new(SSL_METHOD *method);
    00136
    00137    /*
    00138     *   SSL_CTX_free - free an allocated SSL_CTX object
    00139     */
    00140    void SSL_CTX_free(SSL_CTX *ctx);
    00141
    00142    /*
    00143     *   SSL_set_fd - connect the SSL object with a file descriptor
    00144     */
    00145    int SSL_set_fd(SSL *ssl, int fd);
    00146
    00147    /*
    00148     *   SSL_pending - obtain number of readable bytes buffered in an SSL object
    00149     */
    00150    int SSL_pending(SSL *ssl);
    00151
    00152    /*
    00153     *   SSL_peek - obtain bytes buffered in an SSL object
    00154     */
    00155    int SSL_peek(SSL *ssl, void *buf, int num);
    00156
    00157    /*
    00158     *   SSL_CTX_set_cipher_list - choose list of available SSL_CIPHERs
    00159     */
    00160    int SSL_CTX_set_cipher_list(SSL_CTX *ctx, const char *str);
    00161
    00162    /*
    00163     *   SSL_CTX_set_verify - set peer certificate verification parameters
    00164     */
    00165    void SSL_CTX_set_verify(SSL_CTX *ctx, int mode,
    00166                          int (*verify_callback)(int, X509_STORE_CTX *));
    00167
    00168    /*
    00169     *   SSL_use_certificate - load certificate
    00170     */
    00171    int SSL_use_certificate(SSL *ssl, X509 *x);
    00172
    00173    /*
    00174     *   SSL_get_current_cipher - get SSL_CIPHER of a connection
    00175     */
    00176    SSL_CIPHER *SSL_get_current_cipher(SSL *ssl);
    00177
    00178    /*
    00179     *   SSL_set_options - manipulate SSL engine options
    00180     *   Note: These are all mapped to SSL_ctrl so call them as the comment
    00181     *         specifies but know that they use SSL_ctrl.  They are #define
    00182     *         so they will map to the one in this class if called as a
    00183     *         member function of this class.
    00184     */
    00185    /* long SSL_set_options(SSL *ssl, long options); */
    00186    /*   Returns 0 if not reused, 1 if session id is reused */
    00187    /*   int SSL_session_reused(SSL *ssl); */
    00188    long    SSL_ctrl(SSL *ssl,int cmd, long larg, char *parg);
    00189
    00190    /*
    00191     *   RAND_egd - set the path to the EGD
    00192     */
    00193    int RAND_egd(const char *path);
    00194
    00195
    00196    /*
    00197     *   RAND_file_name
    00198     */
    00199    const char *RAND_file_name(char *buf, size_t num);
    00200
    00201
    00202    /*
    00203     *   RAND_load_file
    00204     */
    00205    int RAND_load_file(const char *filename, long max_bytes);
    00206
    00207
    00208    /*
    00209     *   RAND_write_file
    00210     */
    00211    int RAND_write_file(const char *filename);
    00212
    00213
    00214    /*
    00215     *   TLSv1_client_method - return a TLSv1 client method object
    00216     */
    00217    SSL_METHOD *TLSv1_client_method();
    00218
    00219
    00220    /*
    00221     *   SSLv2_client_method - return a SSLv2 client method object
    00222     */
    00223    SSL_METHOD *SSLv2_client_method();
    00224
    00225
    00226    /*
    00227     *   SSLv3_client_method - return a SSLv3 client method object
    00228     */
    00229    SSL_METHOD *SSLv3_client_method();
    00230
    00231
    00232    /*
    00233     *   SSLv23_client_method - return a SSLv23 client method object
    00234     */
    00235    SSL_METHOD *SSLv23_client_method();
    00236
    00237
    00238    /*
    00239     *   SSL_get_peer_certificate - return the peer's certificate
    00240     */
    00241    X509 *SSL_get_peer_certificate(SSL *s);
    00242
    00243
    00244    /*
    00245     *   SSL_get_peer_cert_chain - get the peer's certificate chain
    00246     */
    00247    STACK_OF(X509) *SSL_get_peer_cert_chain(SSL *s);
    00248
    00249    /*
    00250     *   SSL_CIPHER_get_bits - get the number of bits in this cipher
    00251     */
    00252    int SSL_CIPHER_get_bits(SSL_CIPHER *c,int *alg_bits);
    00253
    00254
    00255    /*
    00256     *   SSL_CIPHER_get_version - get the version of this cipher
    00257     */
    00258    char *SSL_CIPHER_get_version(SSL_CIPHER *c);
    00259
    00260
    00261    /*
    00262     *   SSL_CIPHER_get_name - get the name of this cipher
    00263     */
    00264    const char *SSL_CIPHER_get_name(SSL_CIPHER *c);
    00265
    00266
    00267    /*
    00268     *   SSL_CIPHER_description - get the description of this cipher
    00269     */
    00270    char *SSL_CIPHER_description(SSL_CIPHER *,char *buf,int size);
    00271
    00272
    00273    /*
    00274     *   SSL_CTX_use_PrivateKey - set the private key for the session.
    00275     *                          - for use with client certificates
    00276     */
    00277    int SSL_CTX_use_PrivateKey(SSL_CTX *ctx, EVP_PKEY *pkey);
    00278
    00279
    00280    /*
    00281     *   SSL_CTX_use_certificate - set the client certificate for the session.
    00282     */
    00283    int SSL_CTX_use_certificate(SSL_CTX *ctx, X509 *x);
    00284
    00285
    00286    /*
    00287     *   d2i_X509 - Covert a text representation of X509 to an X509 object
    00288     */
    00289    X509 * d2i_X509(X509 **a,unsigned char **pp,long length);
    00290
    00291
    00292    /*
    00293     *   i2d_X509 - Covert an X509 object into a text representation
    00294     */
    00295    int i2d_X509(X509 *a,unsigned char **pp);
    00296
    00297
    00298    /*
    00299     *   X509_cmp - compare two X509 objects
    00300     */
    00301    int X509_cmp(X509 *a, X509 *b);
    00302
    00303
    00304    /*
    00305     *   X509_dup - duplicate an X509 object
    00306     */
    00307    X509 *X509_dup(X509 *x509);
    00308
    00309
    00310    /*
    00311     *   X509_STORE_CTX_new - create an X509 store context
    00312     */
    00313    X509_STORE_CTX *X509_STORE_CTX_new(void);
    00314
    00315
    00316    /*
    00317     *   X509_STORE_CTX_free - free up an X509 store context
    00318     */
    00319    void X509_STORE_CTX_free(X509_STORE_CTX *v);
    00320
    00321
    00322    /*
    00323     *   X509_STORE_CTX_set_chain - set the certificate chain
    00324     */
    00325    void X509_STORE_CTX_set_chain(X509_STORE_CTX *v, STACK_OF(X509)* x);
    00326
    00327    /*
    00328     *   X509_STORE_CTX_set_purpose - set the purpose of the certificate
    00329     */
    00330    void X509_STORE_CTX_set_purpose(X509_STORE_CTX *v, int purpose);
    00331
    00332    /*
    00333     *   X509_verify_cert - verify the certificate
    00334     */
    00335    int X509_verify_cert(X509_STORE_CTX *v);
    00336
    00337
    00338    /*
    00339     *   X509_STORE_new - create an X509 store
    00340     */
    00341    X509_STORE *X509_STORE_new(void);
    00342
    00343
    00344    /*
    00345     *   X509_STORE_free - free up an X509 store
    00346     */
    00347    void X509_STORE_free(X509_STORE *v);
    00348
    00349
    00350    /*
    00351     *   X509_free - free up an X509
    00352     */
    00353    void X509_free(X509 *v);
    00354
    00355
    00356    /*
    00357     *   X509_NAME_oneline - return the X509 data in a string
    00358     */
    00359    char *X509_NAME_oneline(X509_NAME *a, char *buf, int size);
    00360
    00361
    00362    /*
    00363     *   X509_get_subject_name - return the X509_NAME for the subject field
    00364     */
    00365    X509_NAME *X509_get_subject_name(X509 *a);
    00366
    00367
    00368    /*
    00369     *   X509_get_issuer_name - return the X509_NAME for the issuer field
    00370     */
    00371    X509_NAME *X509_get_issuer_name(X509 *a);
    00372
    00373
    00374    /*
    00375     *   X509_STORE_add_lookup - add a lookup file/method to an X509 store
    00376     */
    00377    X509_LOOKUP *X509_STORE_add_lookup(X509_STORE *v, X509_LOOKUP_METHOD *m);
    00378
    00379
    00380    /*
    00381     *   X509_LOOKUP_file - Definition of the LOOKUP_file method
    00382     */
    00383    X509_LOOKUP_METHOD *X509_LOOKUP_file(void);
    00384
    00385
    00386    /*
    00387     *   X509_LOOKUP_free - Free an X509_LOOKUP
    00388     */
    00389    void X509_LOOKUP_free(X509_LOOKUP *x);
    00390
    00391
    00392    /*
    00393     *   X509_LOOKUP_ctrl - This is not normally called directly (use macros)
    00394     */
    00395    int X509_LOOKUP_ctrl(X509_LOOKUP *ctx, int cmd, const char *argc, long argl, char **ret);
    00396
    00397
    00398    /*
    00399     *   X509_STORE_CTX_init - initialize an X509 STORE context
    00400     */
    00401    void X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store, X509 *x509, STACK_OF(X509) *chain);
    00402
    00403
    00404    /*
    00405     *   CRYPTO_free - free up an internally allocated object
    00406     */
    00407    void CRYPTO_free(void *x);
    00408
    00409    /*
    00410     *   BIO_new - create new BIO
    00411     */
    00412    BIO *BIO_new(BIO_METHOD *type);
    00413
    00414    /*
    00415     *   BIO methods - only one defined here yet
    00416     */
    00417    BIO_METHOD *BIO_s_mem(void);
    00418
    00419    /*
    00420     *   BIO_new_fp - nastiness called BIO - used to create BIO* from FILE*
    00421     */
    00422    BIO *BIO_new_fp(FILE *stream, int close_flag);
    00423
    00424    /*
    00425     *   BIO_new_mem_buf - read only BIO from memory region
    00426     */
    00427    BIO *BIO_new_mem_buf(void *buf, int len);
    00428
    00429    /*
    00430     *   BIO_free - nastiness called BIO - used to destroy BIO*
    00431     */
    00432    int BIO_free(BIO *a);
    00433
    00434    /*
    00435     *   BIO_ctrl - BIO control method
    00436     */
    00437    long BIO_ctrl(BIO *bp,int cmd,long larg,void *parg);
    00438
    00439    /*
    00440     *   BIO_write - equivalent to ::write for BIO
    00441     */
    00442    int BIO_write(BIO *b, const void *data, int len);
    00443
    00444    /*
    00445     *   PEM_write_bio_X509 - write a PEM encoded cert to a BIO*
    00446     */
    00447    int PEM_write_bio_X509(BIO *bp, X509 *x);
    00448
    00449
    00450    /*
    00451     *   X509_asn1_meth - used for netscape output
    00452     */
    00453    ASN1_METHOD *X509_asn1_meth();
    00454
    00455
    00456    /*
    00457     *   ASN1_i2d_fp - used for netscape output
    00458     */
    00459    int ASN1_i2d_fp(FILE *out, unsigned char *x);
    00460
    00461
    00462    /*
    00463     *   ASN1_d2i_fp - read an X509 from a DER encoded file (buf can be NULL)
    00464     */
    00465    X509 *X509_d2i_fp(FILE *out, X509** buf);
    00466
    00467
    00468    /*
    00469     *   X509_print - print the text form of an X509
    00470     */
    00471    int X509_print(FILE *fp, X509 *x);
    00472
    00473
    00474    /*
    00475     *   Read a PKCS#12 cert from fp
    00476     */
    00477    PKCS12 *d2i_PKCS12_fp(FILE *fp, PKCS12 **p12);
    00478
    00479
    00480    /*
    00481     *   Change the password on a PKCS#12 cert
    00482     */
    00483    int PKCS12_newpass(PKCS12 *p12, char *oldpass, char *newpass);
    00484
    00485
    00486    /*
    00487     *   Write a PKCS#12 to mem
    00488     */
    00489    int i2d_PKCS12(PKCS12 *p12, unsigned char **p);
    00490
    00491
    00492    /*
    00493     *   Write a PKCS#12 to FILE*
    00494     */
    00495    int i2d_PKCS12_fp(FILE *fp, PKCS12 *p12);
    00496
    00497
    00498    /*
    00499     *   Create a new PKCS#12 object
    00500     */
    00501    PKCS12 *PKCS12_new(void);
    00502
    00503
    00504    /*
    00505     *   Destroy that PKCS#12 that you created!
    00506     */
    00507    void PKCS12_free(PKCS12 *a);
    00508
    00509
    00510    /*
    00511     *   Parse the PKCS#12
    00512     */
    00513    int PKCS12_parse(PKCS12 *p12, const char *pass, EVP_PKEY **pkey,
    00514                     X509 **cert, STACK_OF(X509) **ca);
    00515
    00516
    00517    /*
    00518     *   Free the Private Key
    00519     */
    00520    void EVP_PKEY_free(EVP_PKEY *x);
    00521
    00522
    00523    /*
    00524     *   Pop off the stack
    00525     */
    00526    char *sk_pop(STACK *s);
    00527
    00528
    00529    /*
    00530     *   Free the stack
    00531     */
    00532    void sk_free(STACK *s);
    00533
    00534
    00535    /*
    00536     *  Number of elements in the stack
    00537     */
    00538    int sk_num(STACK *s);
    00539
    00540
    00541    /*
    00542     *  Value of element n in the stack
    00543     */
    00544    char *sk_value(STACK *s, int n);
    00545
    00546
    00547    /*
    00548     *  Create a new stack
    00549     */
    00550    STACK *sk_new(int (*cmp)());
    00551
    00552
    00553    /*
    00554     *  Add an element to the stack
    00555     */
    00556    int sk_push(STACK *s, char *d);
    00557
    00558
    00559    /*
    00560     *  Duplicate the stack
    00561     */
    00562    STACK *sk_dup(STACK *s);
    00563
    00564
    00565    /*
    00566     *  Convert an ASN1_INTEGER to it's text form
    00567     */
    00568    char *i2s_ASN1_INTEGER(X509V3_EXT_METHOD *meth, ASN1_INTEGER *aint);
    00569
    00570
    00571    /*
    00572     *  Get the certificate's serial number
    00573     */
    00574    ASN1_INTEGER *X509_get_serialNumber(X509 *x);
    00575
    00576
    00577    /*
    00578     *  Get the certificate's public key
    00579     */
    00580    EVP_PKEY *X509_get_pubkey(X509 *x);
    00581
    00582
    00583    /*
    00584     *  Convert the public key to a decimal form
    00585     */
    00586    int i2d_PublicKey(EVP_PKEY *a, unsigned char **pp);
    00587
    00588
    00589    /*
    00590     *  Check the private key of a PKCS bundle against the X509
    00591     */
    00592    int X509_check_private_key(X509 *x, EVP_PKEY *p);
    00593
    00594
    00595    /*
    00596     *  Convert a BIGNUM to a hex string
    00597     */
    00598    char *BN_bn2hex(const BIGNUM *a);
    00599
    00600
    00601    /*
    00602     *  Compute the digest of an X.509
    00603     */
    00604    int X509_digest(const X509 *x,const EVP_MD *t, unsigned char *md, unsigned int *len);
    00605
    00606
    00607    /*
    00608     *  EVP_md5
    00609     */
    00610    EVP_MD *EVP_md5();
    00611
    00612
    00613    /*
    00614     *  ASN1_INTEGER free
    00615     */
    00616    void ASN1_INTEGER_free(ASN1_INTEGER *x);
    00617
    00618
    00619    /*
    00620     *  ASN1_STRING_data
    00621     */
    00622    unsigned char *ASN1_STRING_data(ASN1_STRING *x);
    00623
    00624    /*
    00625     *
    00626     */
    00627    int OBJ_obj2nid(ASN1_OBJECT *o);
    00628
    00629    /*
    00630     *
    00631     */
    00632    const char * OBJ_nid2ln(int n);
    00633
    00634    /*
    00635     * get the number of extensions
    00636     */
    00637    int X509_get_ext_count(X509 *x);
    00638
    00639    /*
    00640     *
    00641     */
    00642    int X509_get_ext_by_NID(X509 *x, int nid, int lastpos);
    00643
    00644    /*
    00645     *
    00646     */
    00647    int X509_get_ext_by_OBJ(X509 *x,ASN1_OBJECT *obj,int lastpos);
    00648
    00649    /*
    00650     *
    00651     */
    00652    X509_EXTENSION *X509_get_ext(X509 *x, int loc);
    00653
    00654    /*
    00655     *
    00656     */
    00657    X509_EXTENSION *X509_delete_ext(X509 *x, int loc);
    00658
    00659    /*
    00660     *
    00661     */
    00662    int X509_add_ext(X509 *x, X509_EXTENSION *ex, int loc);
    00663
    00664    /*
    00665     *
    00666     */
    00667    void *X509_get_ext_d2i(X509 *x, int nid, int *crit, int *idx);
    00668
    00669    /*
    00670     *
    00671     */
    00672    char *i2s_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method, ASN1_OCTET_STRING *ia5);
    00673
    00674    /*
    00675     *
    00676     */
    00677    int ASN1_BIT_STRING_get_bit(ASN1_BIT_STRING *a, int n);
    00678
    00679    /*
    00680     *
    00681     */
    00682    PKCS7 *PKCS7_new(void);
    00683
    00684    /*
    00685     *
    00686     */
    00687    void PKCS7_free(PKCS7 *a);
    00688
    00689    /*
    00690     *
    00691     */
    00692    void PKCS7_content_free(PKCS7 *a);
    00693
    00694    /*
    00695     *
    00696     */
    00697    int i2d_PKCS7(PKCS7 *a, unsigned char **pp);
    00698
    00699    /*
    00700     *
    00701     */
    00702    PKCS7 *d2i_PKCS7(PKCS7 **a, unsigned char **pp,long length);
    00703
    00704    /*
    00705     *
    00706     */
    00707    int i2d_PKCS7_fp(FILE *fp,PKCS7 *p7);
    00708
    00709    /*
    00710     *
    00711     */
    00712    PKCS7 *d2i_PKCS7_fp(FILE *fp,PKCS7 **p7);
    00713
    00714    /*
    00715     *
    00716     */
    00717    int i2d_PKCS7_bio(BIO *bp,PKCS7 *p7);
    00718
    00719    /*
    00720     *
    00721     */
    00722    PKCS7 *d2i_PKCS7_bio(BIO *bp,PKCS7 **p7);
    00723
    00724    /*
    00725     *
    00726     */
    00727    PKCS7 *PKCS7_dup(PKCS7 *p7);
    00728
    00729    /*
    00730     *  Create a PKCS7 signature / signed message
    00731     */
    00732    PKCS7 *PKCS7_sign(X509 *signcert, EVP_PKEY *pkey, STACK_OF(X509) *certs,
    00733              BIO *data, int flags);
    00734
    00735    /*
    00736     *  Verify a PKCS7 signature.
    00737     */
    00738    int PKCS7_verify(PKCS7 *p7, STACK_OF(X509) *certs, X509_STORE *store,
    00739                                               BIO *indata, BIO *out, int flags);
    00740
    00741    /*
    00742     *  Get signers of a verified PKCS7 signature
    00743     */
    00744    STACK_OF(X509) *PKCS7_get0_signers(PKCS7 *p7, STACK_OF(X509) *certs, int flags);
    00745
    00746    /*
    00747     *  PKCS7 encrypt message
    00748     */
    00749    PKCS7 *PKCS7_encrypt(STACK_OF(X509) *certs, BIO *in, EVP_CIPHER *cipher,
    00750             int flags);
    00751
    00752    /*
    00753     *  decrypt PKCS7 message
    00754     */
    00755    int PKCS7_decrypt(PKCS7 *p7, EVP_PKEY *pkey, X509 *cert, BIO *data, int flags);
    00756
    00757
    00758    /*
    00759     * Load a CA list file.
    00760     */
    00761    STACK_OF(X509_NAME) *SSL_load_client_CA_file(const char *file);
    00762
    00763    /*
    00764     * Load a file of PEM encoded objects.
    00765     */
    00766    STACK_OF(X509_INFO) *PEM_X509_INFO_read(FILE *fp, STACK_OF(X509_INFO) *sk,
    00767                    pem_password_cb *cb, void *u);
    00768
    00769    /*
    00770     * Get the number of purposes available
    00771     */
    00772    int X509_PURPOSE_get_count();
    00773
    00774
    00775    /*
    00776     * Get the ID of a purpose
    00777     */
    00778    int X509_PURPOSE_get_id(X509_PURPOSE *);
    00779
    00780
    00781    /*
    00782     * Check the existence of purpose id "id" in x.  for CA, set ca = 1, else 0
    00783     */
    00784    int X509_check_purpose(X509 *x, int id, int ca);
    00785
    00786
    00787    /*
    00788     * Get the purpose with index #idx
    00789     */
    00790    X509_PURPOSE * X509_PURPOSE_get0(int idx);
    00791
    00792
    00793    /*
    00794     * Create a new Private KEY
    00795     */
    00796    EVP_PKEY* EVP_PKEY_new();
    00797
    00798
    00799    /*
    00800     * Assign a private key
    00801     */
    00802    int EVP_PKEY_assign(EVP_PKEY *pkey, int type, char *key);
    00803
    00804
    00805    /*
    00806     * Generate a RSA key
    00807     */
    00808    RSA *RSA_generate_key(int bits, unsigned long e, void
    00809                         (*callback)(int,int,void *), void *cb_arg);
    00810
    00811
    00812    /*
    00813     * Create/destroy a certificate request
    00814     */
    00815    X509_REQ *X509_REQ_new();
    00816    void X509_REQ_free(X509_REQ *a);
    00817
    00818
    00819    /*
    00820     * Set the public key in the REQ object
    00821     */
    00822    int X509_REQ_set_pubkey(X509_REQ *x, EVP_PKEY *pkey);
    00823
    00824    /* for testing */
    00825    int i2d_X509_REQ_fp(FILE *fp, X509_REQ *x);
    00826
    00827    /* SMime support */
    00828    STACK *X509_get1_email(X509 *x);
    00829    void X509_email_free(STACK *sk);
    00830
    00831    /* Ciphers needed for SMime */
    00832    EVP_CIPHER *EVP_des_ede3_cbc();
    00833    EVP_CIPHER *EVP_des_cbc();
    00834    EVP_CIPHER *EVP_rc2_cbc();
    00835    EVP_CIPHER *EVP_rc2_64_cbc();
    00836    EVP_CIPHER *EVP_rc2_40_cbc();
    00837
    00838    /* clear the current error  - use this often*/
    00839    void ERR_clear_error();
    00840
    00841    /* retrieve the latest error */
    00842    unsigned long ERR_get_error();
    00843
    00844    /* Print the errors to this stream */
    00845    void ERR_print_errors_fp(FILE *fp);
    00846
    00847    /* Get a pointer to the SSL session id (reference counted) */
    00848    SSL_SESSION *SSL_get1_session(SSL *ssl);
    00849
    00850    /* Frees a pointer to the SSL session id (reference decremented if needed) */
    00851    void SSL_SESSION_free(SSL_SESSION *session);
    00852
    00853    /* Set the SSL session to reuse. */
    00854    int SSL_set_session(SSL *ssl, SSL_SESSION *session);
    00855
    00856    /* Decode ASN.1 to SSL_SESSION */
    00857    SSL_SESSION *d2i_SSL_SESSION(SSL_SESSION **a, unsigned char **pp, long length);
    00858    /* Encode SSL_SESSION to ASN.1 */
    00859    int i2d_SSL_SESSION(SSL_SESSION *in, unsigned char **pp);
    00860
    00861    /* Write privatekey to FILE stream */
    00862    int i2d_PrivateKey_fp(FILE*, EVP_PKEY*);
    00863
    00864    /* Write PKCS#8privatekey to FILE stream */
    00865    int i2d_PKCS8PrivateKey_fp(FILE*, EVP_PKEY*, const EVP_CIPHER*, char*, int, pem_password_cb*, void*);
    00866
    00867    /* Free RSA structure */
    00868    void RSA_free(RSA*);
    00869
    00870    /* Get a blowfish CBC pointer */
    00871    EVP_CIPHER *EVP_bf_cbc();
    00872
    00873    /* Sign a CSR */
    00874    int X509_REQ_sign(X509_REQ*, EVP_PKEY*, const EVP_MD*);
    00875
    00876    /* add a name entry */
    00877    int X509_NAME_add_entry_by_txt(X509_NAME*, char*, int, unsigned char*, int, int, int);
    00878
    00879    /* Create a name */
    00880    X509_NAME *X509_NAME_new();
    00881
    00882    /* Set the subject */
    00883    int X509_REQ_set_subject_name(X509_REQ*,X509_NAME*);
    00884
    00885 #endif
    00886
    00887 private:
    00888    KOpenSSLProxy();
    00889    ~KOpenSSLProxy();
    00890    KOpenSSLProxyPrivate *d;
    00891
    00892    KLibrary *_sslLib;
    00893    KLibrary *_cryptoLib;
    00894    static KOpenSSLProxy *_me;
    00895
    00896    bool _ok;
    00897 };
    00898
    00899 #endif
    00900

This file is part of the documentation for kio Library Version 3.4.1.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Sat Jun 11 20:24:02 2005 by doxygen 1.4.1 written by Dimitri van Heesch, © 1997-2003