OpenSSL License
  ---------------
 ====================================================================
 * Copyright (c) 1998-2002 The OpenSSL Project.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer. 
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 3. All advertising materials mentioning features or use of this
 *    software must display the following acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
 *    endorse or promote products derived from this software without
 *    prior written permission. For written permission, please contact
 *    openssl-core@openssl.org.
 * 5. Products derived from this software may not be called "OpenSSL"
 *    nor may "OpenSSL" appear in their names without prior written
 *    permission of the OpenSSL Project.
 * 6. Redistributions of any form whatsoever must retain the following
 *    acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ‘‘AS IS’’ AND ANY
 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 * ====================================================================
 *
 * This product includes cryptographic software written by Eric Young
 * (eay@cryptsoft.com).  This product includes software written by Tim
 * Hudson (tjh@cryptsoft.com).
 *
 */ Original SSLeay License
    -----------------------

 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 * 
 * This library is free for commercial and non-commercial use as long as
 * the following conditions are aheared to.  The following conditions
 * apply to all code found in this distribution, be it the RC4, RSA,
 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
 * included with this distribution is covered by the same copyright terms
 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
 *
 * Copyright remains Eric Young’s, and as such any Copyright notices in
 * the code are not to be removed.
 * If this package is used in a product, Eric Young should be given attribution
 * as the author of the parts of the library used.
 * This can be in the form of a textual message at program startup or
 * in documentation (online or textual) provided with the package.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *    "This product includes cryptographic software written by
 *     Eric Young (eay@cryptsoft.com)"
 *    The word ’cryptographic’ can be left out if the rouines from the library
 *    being used are not cryptographic related :-).
 * 4. If you include any Windows specific code (or a derivative thereof) from 
 *    the apps directory (application code) you must include an acknowledgement:
 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
 * 
 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ‘‘AS IS’’ AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * 
 * The licence and distribution terms for any publically available version or
 * derivative of this code cannot be changed.  i.e. this code cannot simply be
 * copied and put under another distribution licence
 * [including the GNU Public Licence.]
 */

$ product install ssl/source=dka300:[kits]

   1 - CPQ AXPVMS SSL V1.0                 Layered Product
   2 - CPQ AXPVMS SSL T1.0                 Layered Product
   3 - All products listed above
   4 - Exit

Choose one or more items from the menu separated by commas: 1

The following product has been selected:
    CPQ AXPVMS SSL V1.0                    Layered Product

Do you want to continue? [YES]

Configuration phase starting ...

You will be asked to choose options, if any, for each selected product
and for any products that may be installed to satisfy software 
dependency requirements.

CPQ AXPVMS SSL V1.0: SSL for OpenVMS Alpha V1.0 (Based on OpenSSL 0.9.6B).

    (c) Compaq Computer Corporation 2002. All rights reserved.

Do you want the defaults for all options? [YES]

Do you want to review the options? [NO]

Execution phase starting ...

The following product will be installed to destination:
    CPQ AXPVMS SSL V1.0                    DISK$DWLLNG_A_V73:[VMS$COMMON.]
The following product will be removed from destination:
    CPQ AXPVMS SSL T1.0                    DISK$DWLLNG_A_V73:[VMS$COMMON.]

Portion done: 0%...10%...20%...30%...40%...50%...60%...70%...80%...90%...100%

The following product has been installed:
    CPQ AXPVMS SSL V1.0                    Layered Product
The following product has been removed:
    CPQ AXPVMS SSL T1.0                    Layered Product

%PCSI-I-IVPEXECUTE, executing test procedure for CPQ AXPVMS SSL V1.0 ... 
%PCSI-I-IVPSUCCESS, test procedure completed successfully

CPQ AXPVMS SSL V1.0: SSL for OpenVMS Alpha V1.0 (Based on OpenSSL 0.9.6B).

    Insert the following lines in SYS$MANAGER:SYSTARTUP_VMS.COM:
        @sys$startup:ssl$startup.com
    Insert the following lines in SYS$MANAGER:SYSHUTDWN.COM:
        @sys$startup:ssl$shutdown.com

    There are post installation activities that need to be performed.

    This includes things like defining logical names and running SSL$UTILS.COM
    to define some foreign symbols, and running the IVP if it was not done
    as part of the installation.  Refer to the Release Notes for more
    information about activities that should be performed once the installation
    has finished.

    SSL has created the following directory structure in
    PCSI$DESTINATION, which defaults to SYS$SYSDEVICE:[VMS$COMMON]:

     [SSL] -                Top-level SSL directory
     [SSL.ALPHA_EXE] -      Contains the images for the Alpha platform.
     [SSL.COM] -            Directory to hold the various command procedures.
     [SSL.DEMOCA] -         Directory structure to demo SSL’s CA features
     [SSL.DEMOCA.CERTS] -   Directory to hold the certificates and keys
     [SSL.DEMOCA.CONF] -    Contains the configuration files.
     [SSL.DEMOCA.CRL] -     Contains revoked certificates and CRLs
     [SSL.DEMOCA.PRIVATE] - Directory for private keys and random data.
     [SSL.INCLUDE] -        Contains the C Header (.H) files.
     [SSL.TEST] -           Contains the files used during the IVP.


    Refer to SYS$HELP:SSL010.RELEASE_NOTES for more information.

    @SYS$STARTUP:SSL$STARTUP.COM should be run at system startup.
$

$ CC/POINTER_SIZE=64/PREFIX=ALL SAMPLE.C
$ LINK/MAP SAMPLE,LINKER_OPT/OPTIONS

SYS$SHARE:SSL$LIBSSL_SHR/SHARE
SYS$SHARE:SSL$LIBCRYPTO_SHR/SHARE

$ CC/PREFIX=ALL SAMPLE.C
$ LINK/MAP SAMPLE,LINKER_OPT/OPTIONS

SYS$SHARE:SSL$LIBSSL_SHR32/SHARE
SYS$SHARE:SSL$LIBCRYPTO_SHR32/SHARE

SYS$SHARE:SSL$LIBCRYPTO_SHR.EXE/SHARE
SYS$SHARE:SSL$LIBSSL_SHR.EXE/SHARE

bind: address already in use

int   on = 1;
ret = setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, (void *)

&on, sizeof(on));

$ cxx/list/PREFIX=(ALL_ENTRIES) serv.c

        	struct CRYPTO_dynlock_value *data;
	........^
	%CXX-W-CANTCOMPLETE, In this declaration, the incomplete class 
   "unnamed struct::CRYPTO_dynlock_value" 
	 cannot be completed because it is declared within a 
    class or a function prototype.
	 at line number 161 in file 
    CRYPTO$RES:[OSSL.BUILD_0049_ALPHA_32.INCLUDE.OPENSSL]CRYPTO.H;3

nsCertType = client

$ @SSL$COM:SSL$CERT_TOOL

-----BEGIN CERTIFICATE REQUEST-----
MIIB/TCCAWYCAQAwgbwxCzAJBgNVBAYTAlVTMRYwFAYDVQQIEw1OZXcgSGFtcHNo
aXJlMQ8wDQYDVQQHEwZOYXNodWExHjAcBgNVBAoTFUNvbXBhcSBDb21wdXRlciBD 
b3JwLjEcMBoGA1UECxMTT3BlblZNUyBFbmdpbmVlcmluZzEaMBgGA1UEAxMRRkxJ 
UDMuWktPLkRFQy5DT00xKjAoBgkqhkiG9w0BCQEWG3dlYm1hc3RlckBGTElQMy5a 
S08uREVDLkNPTTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA0/y8RxuE/COy 
nVpeK00GgvbgFWxX1o89ULQTMVUSwmAzhdzbi3DZL5s85YRGdPVgYW2rWs1t2SQg 
jMSlFTxta/CwW6Vwwn9GmdaJwkqGFxnpw2LmugexLfj+4t97AZyIR2O7gJxCINS5 
CWg3tcn1ZUmqswjkrG8WehUN+2C6IBcCAwEAAaAAMA0GCSqGSIb3DQEBBAUAA4GB 
ABzgiiojPAcojLXGI2OFxJ5apORAHHHAyc0YCuhFXS1Rs2BIXHmM5xQuxk8yitc4 
yViQfHhGDzpDmOwMKkK7t09UjQh9humKEUlAnS4VYLL4VlgenwLybcLLB0Q3aiQN 
UjQw9RrXNWWZYVDenvrOwtbK9dFefb4PlZIAS2/Z4jLP
-----END CERTIFICATE REQUEST-----

-----BEGIN CERTIFICATE-----
MIICeDCCAiICEEdpjxOzmJPyh5TiG8BRA70wDQYJKoZIhvcNAQEEBQAwgakxFjAU 
BgNVBAoTDVZlcmlTaWduLCBJbmMxRzBFBgNVBAsTPnd3dy52ZXJpc2lnbi5jb20v 
cmVwb3NpdG9yeS9UZXN0Q1BTIEluY29ycC4gQnkgUmVmLiBMaWFiLiBMVEQuMUYw 
RAYDVQQLEz1Gb3IgVmVyaVNpZ24gYXV0aG9yaXplZCB0ZXN0aW5nIG9ubHkuIE5v 
IGFzc3VyYW5jZXMgKEMpVlMxOTk3MB4XDTAwMDcwNzAwMDAwMFoXDTAwMDcyMTIz
NTk1OVowgZAxCzAJBgNVBAYTAlVTMRYwFAYDVQQIEw1OZXcgSGFtcHNoaXJlMQ8w 
DQYDVQQHFAZOYXNodWExHjAcBgNVBAoUFUNvbXBhcSBDb21wdXRlciBDb3JwLjEc 
MBoGA1UECxQTT3BlblZNUyBFbmdpbmVlcmluZzEaMBgGA1UEAxQRRkxJUDMuWktP 
LkRFQy5DT00wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBANP8vEcbhPwjsp1a 
XitNBoL24BVsV9aPPVC0EzFVEsJgM4Xc24tw2S+bPOWERnT1YGFtq1rNbdkkIIzE 
pRU8bWvwsFulcMJ/RpnWicJKhhcZ6cNi5roHsS34/uLfewGciEdju4CcQiDUuQlo 
N7XJ9WVJqrMI5KxvFnoVDftguiAXAgMBAAEwDQYJKoZIhvcNAQEEBQADQQAySLLe 
U7nMLJ+QkRld6iqKjU2VotphPvgWMGsJ+TKqUI4MXaAv0zQxtBni1N8s0LXVNCuJ
lEzBYjSbgbgEhJJA
-----END CERTIFICATE-----

$ COPY CLIENT_CERT.PEM, INTER_CA1.PEM, INTER_CA2.PEM, -
_$ ROOT_CA.PEM, CERT_CHAIN.PEM

SSL_library_init(); /* load encryption & hash algorithms for SSL */         	
SSL_load_error_strings(); /* load the error strings for good error reporting */

meth = SSLv3_method();
ctx = SSL_CTX_new(meth);

int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile, 
const char *CApath);

/* Set a callback function (verify_callback) for peer certificate */
/* verification */
SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, verify_callback);

/* Set the verification depth to 1 */
SSL_CTX_set_verify_depth(ctx,1);

SSL_CTX_set_verify_depth(ctx, 1);

	err = SSL_connect(ssl);
	
if(SSL_get_peer_certificate(ssl) != NULL)
{
	      if(SSL_get_verify_result(ssl) == X509_V_OK)
		BIO_printf(bio_c_out, "client verification with SSL_get_verify_result() 
     succeeded.\n");                
	      else{
		BIO_printf(bio_err, "client verification with SSL_get_verify_result() 
     failed.\n");
		exit(1);
	      }
}
	else
      BIO_printf(bio_c_out, “the peer certificate was not presented.\n”);

 /* Load server certificate into the SSL context */
       	 if (SSL_CTX_use_certificate_file(ctx, SERVER_CERT, 
         SSL_FILETYPE_PEM) <= 0) {
                	ERR_print_errors(bio_err);  /* == 
                  ERR_print_errors_fp(stderr); */
                	exit(1);
        	}

       	 /* Load the server private-key into the SSL context */
        	if (SSL_CTX_use_PrivateKey_file(ctx, SERVER_KEY, 
          SSL_FILETYPE_PEM) <= 0) {
                	ERR_print_errors(bio_err);  /* == 
                  ERR_print_errors_fp(stderr); */
                	exit(1);
        	}

/* Load trusted CA. */
        	if (!SSL_CTX_load_verify_locations(ctx,CA_CERT,NULL)) {
                	ERR_print_errors(bio_err);  /* == 
                  ERR_print_errors_fp(stderr); */
                	exit(1);
        	}

       	 /* Set to require peer (client) certificate verification */
        	SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, verify_callback);

       	/* Set the verification depth to 1 */
        	SSL_CTX_set_verify_depth(ctx,1);

/*----- Load a client certificate into the SSL_CTX structure -----*/
       if(SSL_CTX_use_certificate_file(ctx,CLIENT_CERT,
       SSL_FILETYPE_PEM) <= 0){
              	ERR_print_errors_fp(stderr);
              	exit(1);
       	}
/*----- Load a private-key into the SSL_CTX structure -----*/
        if(SSL_CTX_use_PrivateKey_file(ctx,CLIENT_KEY,
        SSL_FILETYPE_PEM) <= 0){
              	ERR_print_errors_fp(stderr);
              	exit(1);
        	}

/* Load trusted CA. */
        	if (!SSL_CTX_load_verify_locations(ctx,CA_CERT,NULL)) {
                	ERR_print_errors_fp(stderr);
                	exit(1);
        	}

ssl = SSL_new(ctx);

SSL_set_fd(ssl, sock);

sbio = BIO_new_socket(socket, BIO_NOCLOSE);
SSL_set_bio(ssl, sbio, sbio);

sbio=BIO_new(BIO_s_socket());
BIO_set_fd(sbio, sock, BIO_NOCLOSE);
SSL_set_bio(ssl, sbio, sbio);

err = SSL_accept(ssl);

err = SSL_connect(ssl);

/* When SSL_accept() is not called, SSL_set_accept_state() */ 
/* must be called prior to SSL_read() */
SSL_set_accept_state(ssl);

/* When SSL_connect() is not called, SSL_set_connect_state() */ 
/* must be called prior to 
SSL_write() */
	SSL_set_connect_state(ssl);

peer_cert = SSL_get_peer_certificate(ssl);

err = SSL_write(ssl, wbuf, strlen(wbuf));

err = SSL_read(ssl, rbuf, sizeof(rbuf)-1);

BIO 	*buf_io, *ssl_bio;
char	rbuf[READBUF_SIZE];
char	wbuf[WRITEBUF_SIZE]

buf_io = BIO_new(BIO_f_buffer());	/* create a buffer BIO */
ssl_bio = BIO_new(BIO_f_ssl());  		/* create an ssl BIO */
BIO_set_ssl(ssl_bio, ssl, BIO_CLOSE);	/* assign the ssl BIO to SSL */
BIO_push(buf_io, ssl_bio);		/* add ssl_bio to buf_io */			

ret = BIO_puts(buf_io, wbuf);		
/* Write contents of wbuf[] into buf_io */
ret = BIO_write(buf_io, wbuf, wlen);	
/* Write wlen-byte contents of wbuf[] into buf_io */

ret = BIO_gets(buf_io, rbuf, READBUF_SIZE);  
/* Read data from buf_io and store in rbuf[] */
ret = BIO_read(buf_io, rbuf, rlen);		
/* Read rlen-byte data from buf_io and store rbuf[] */

ret = SSL_connect(ssl)
(Use SSL_read() / SSL_write() for data communication 
                  over the SSL connection)

sess = SSL_get1_session(ssl);  
/* sess is an SSL_SESSION, and ssl is an SSL */

SSL_shutdown(ssl);

ssl = SSL_new(ctx);

SSL_set_session(ssl, sess);
err = SSL_connect(ssl);

ret = SSL_connect(ssl)
(Use SSL_read() / SSL_write() for data communication 
over the SSL connection)

## Create a DH parameter (key size is 1024 bits)
   $ openssl dhparam -outform PEM -out dhparam.pem 1024


## Create a DSA certificate
        
- Create DSA parameters (key size is 1024 bits)
  $ openssl dsaparam -out dsaparam.pem 1024

- Create a DSA CA certificate and private key 
(using DSA parameter in dsaparam.pem)        

  $ openssl req -x509 -newkey dsa:dsaparam.pem 
-keyout dsa_ca.key -out dsa_ca.crt -config SSL$CONF

- Create DSA certificate signing request(dsa_cert.csr) 
& private key(dsa_cert.key)

  $ openssl req -out dsa_cert.csr -keyout dsa_cert.key 
-newkey dsa:DSAPARAM.PEM -config SSL$CONF

- Sign Certificate Signing Request with DSA CA Certificate 
and Create a New Certificate

 $ openssl ca -in dsa_cert.csr -out dsa_cert.crt 
-config SSL$CA_CONF

/*
 * ++
 * FACILITY:
 *
 *	Simplest SSL Client
 *
 * ABSTRACT:
 *
 *      This is an example of an SSL client with minimum functionality.
 *      The socket APIs are used to handle TCP/IP operations. 
 *
 *	This SSL client verifies the server’s certificate against the CA
 *	certificate loaded in the client.  
 *
 *	This SSL client does not load its own certificate and key because 
 *	the SSL server does not request nor verify the client certificate.
 *
 *
 * ENVIRONMENT:
 *
 *    OpenVMS Alpha V7.2-2
 *    TCP/IP Services V5.0A or higher
 *
 * AUTHOR:
 *
 *    Taka Shinagawa, OpenVMS Security Group
 *
 * CREATION DATE:
 *
 *    1-Jan-2002
 *
 * --
 */


/* Assumptions, Build, Configuration, and Execution Instructions */

/*
 *  ASSUMPTIONS:
 *
 *    The following are assumed to be true for the
 *    execution of this program to succeed:
 *
 *    - SSL is installed and started on this system.
 *
 *    - this server program, and its accompanying client
 *      program are run on the same system, but in different
 *      processes.
 *
 *    - the certificate and keys referenced by this program
 *      reside in the same directory as this program.  There 
 *      is a command procedure, SSL$EXAMPLES_SETUP.COM, to 
 *      help set up the certificates and keys.
 *
 *
 *  BUILD INSTRUCTIONS:
 *
 *    To build this example program use commands of the form,
 *
 *      For a 32-bit application using only SSL APIs needs to run the 
 *      following commands for SSL_APP.C .
 *       -----------------------------------------------------------------
 *       $CC/POINTER_SIZE=32/PREFIX_LIBRARY_ENTRIES=ALL_ENTRIES SSL_APP.C
 *       $LINK SSL_APP.OBJ, VMS_DECC_OPTIONS.OPT/OPT
 *       -----------------------------------------------------------------
 *       VMS_DECC_OPTIONS.OPT should include the following lines.
 *       -------------------------------------------------
 *       SYS$LIBRARY:OPENSSL$LIBCRYPTO_SHR32.EXE/SHARE
 *       SYS$LIBRARY:OPENSSL$LIBSSL_SHR32.EXE/SHARE
 *       -------------------------------------------------
 *
 *       Creating a 64-bit application of SSL_APP.C should run the 
 *       following commands.
 *       -----------------------------------------------------------------
 *       $CC/POINTER_SIZE=64/PREFIX_LIBRARY_ENTRIES=ALL_ENTRIES SSL_APP.C
 *       $LINK SSL_APP.OBJ, VMS_DECC_OPTIONS.OPT/OPT
 *       -----------------------------------------------------------------
 *       VMS_DECC_OPTIONS.OPT should include the following lines.
 *       -------------------------------------------------
 *       SYS$LIBRARY:OPENSSL$LIBCRYPTO_SHR.EXE/SHARE
 *       SYS$LIBRARY:OPENSSL$LIBSSL_SHR.EXE/SHARE
 *       -------------------------------------------------
 *
 *
 * CONFIGURATION INSTRUCTIONS:
 *
 *
 * RUN INSTRUCTIONS:
 *
 *    To run this example program:
 *
 *    1) Start the server program,
 *
 *       $ run server on this system
 *
 *    2) Start the client program on this same system,
 *
 *       $ run client
 *
 */


#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <netdb.h>
#include <unistd.h>

#ifdef __VMS
#include <socket.h>
#include <inet.h>
#include <in.h>
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#endif

#include <openssl/crypto.h>
#include <openssl/ssl.h>
#include <openssl/err.h>

#define RETURN_NULL(x) if ((x)==NULL) exit (1)
#define RETURN_ERR(err,s) if ((err)==-1) { perror(s); exit(1); }
#define RETURN_SSL(err) if ((err)==-1) { ERR_print_errors_fp(stderr); exit(1); }

static int verify_callback(int ok, X509_STORE_CTX *ctx);

#define RSA_CLIENT_CERT	"client.crt"
#define RSA_CLIENT_KEY 	"client.key"

#define RSA_CLIENT_CA_CERT      "client_ca.crt"
#define RSA_CLIENT_CA_PATH      "sys$common:[syshlp.examples.ssl]"

#define ON      1
#define OFF     0

void main()
{
  	int 	err;
	int 	verify_client = OFF; /* To verify a client certificate, set ON */

  	int 	sock;
  	struct sockaddr_in server_addr;
  	char	*str;
  	char  	buf [4096];
  	char 	hello[80];

	SSL_CTX 	*ctx;
        SSL     	*ssl;
	SSL_METHOD 	*meth;
	X509    	*server_cert;

        EVP_PKEY        *pkey;

	short int 	s_port = 5555;
	const char	*s_ipaddr = "127.0.0.1";
       
	/*----------------------------------------------------------*/
  	printf ("Message to be sent to the SSL server: ");
  	fgets (hello, 80, stdin);
	
	/* Load encryption & hashing algorithms for the SSL program */
	SSL_library_init();

	/* Load the error strings for SSL & CRYPTO APIs */
	SSL_load_error_strings();

	/* Create an SSL_METHOD structure (choose an SSL/TLS protocol version) */
  	meth = SSLv3_method();

	/* Create an SSL_CTX structure */
  	ctx = SSL_CTX_new(meth);                        
	RETURN_NULL(ctx);

	/*----------------------------------------------------------*/
	if(verify_client == ON)
	{
		/* Load the client certificate into the SSL_CTX structure */
		if (SSL_CTX_use_certificate_file(ctx, RSA_CLIENT_CERT, 
     SSL_FILETYPE_PEM) <= 0) {
                	ERR_print_errors_fp(stderr);
                	exit(1);
		}

		/* Load the private-key corresponding to the client certificate */
        	if (SSL_CTX_use_PrivateKey_file(ctx, RSA_CLIENT_KEY, 
          SSL_FILETYPE_PEM) <= 0) {
                	ERR_print_errors_fp(stderr);
                	exit(1);
        	}

		/* Check if the client certificate and private-key matches */
        	if (!SSL_CTX_check_private_key(ctx)) {
                	fprintf(stderr,"Private key does not match the 
                  certificate public key\n");
                	exit(1);
        	}
	}

	/* Load the RSA CA certificate into the SSL_CTX structure */
	/* This will allow this client to verify the server’s     */
	/* certificate.                                           */
	if (!SSL_CTX_load_verify_locations(ctx, RSA_CLIENT_CA_CERT, NULL)) {
       	        ERR_print_errors_fp(stderr);
       	        exit(1);
	}

        /* Set flag in context to require peer (server) certificate */
        /* verification */
        SSL_CTX_set_verify(ctx,SSL_VERIFY_PEER,NULL);
        SSL_CTX_set_verify_depth(ctx,1);

  	/* ------------------------------------------------------------- */
  	/* Set up a TCP socket */
 
  	sock = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);       
	RETURN_ERR(sock, "socket");

  	memset (&server_addr, ’\0’, sizeof(server_addr));
  	server_addr.sin_family      = AF_INET;
	server_addr.sin_port        = htons(s_port);       /* Server Port number */
  	server_addr.sin_addr.s_addr = inet_addr(s_ipaddr); /* Server IP */

	/* Establish a TCP/IP connection to the SSL client */
  	err = connect(sock, (struct sockaddr*) &server_addr, sizeof(server_addr)); 
	RETURN_ERR(err, "connect");

  	/* ----------------------------------------------- */
  	/* An SSL structure is created */
  	ssl = SSL_new (ctx);
	RETURN_NULL(ssl);

	/* Assign the socket into the SSL structure (SSL and socket without BIO) */
  	SSL_set_fd(ssl, sock);

	/* Perform SSL Handshake on the SSL client */
	err = SSL_connect(ssl);
	RETURN_SSL(err);

	/* Informational output (optional) */
  	printf ("SSL connection using %s\n", SSL_get_cipher (ssl));
 

  	/* Get the server’s certificate (optional) */
  	server_cert = SSL_get_peer_certificate (ssl);       
	
	if (server_cert != NULL)
        {
		printf ("Server certificate:\n");

		str = X509_NAME_oneline(X509_get_subject_name(server_cert),0,0);
		RETURN_NULL(str);
		printf ("\t subject: %s\n", str);
		free (str);

		str = X509_NAME_oneline(X509_get_issuer_name(server_cert),0,0);
		RETURN_NULL(str);
		printf ("\t issuer: %s\n", str);
		free(str);

		X509_free (server_cert);
	}
        else
                printf("The SSL server does not have certificate.\n");


  	/*-------- DATA EXCHANGE - send message and receive reply. -------*/

	/* Send data to the SSL server */
  	err = SSL_write(ssl, hello, strlen(hello));  
	RETURN_SSL(err);

	/* Receive data from the SSL server */
  	err = SSL_read(ssl, buf, sizeof(buf)-1);                     
	RETURN_SSL(err);
  	buf[err] = ’\0’;
  	printf ("Received %d chars:’%s’\n", err, buf);

        /*--------------- SSL closure ---------------*/
        /* Shutdown the client side of the SSL connection */
        err = SSL_shutdown(ssl);
        RETURN_SSL(err);

        /* Terminate communication on a socket */
        err = close(sock);
        RETURN_ERR(err, "close");

        /* Free the SSL structure */
        SSL_free(ssl);

        /* Free the SSL_CTX structure */
        SSL_CTX_free(ctx);
}

/*
 * ++
 * FACILITY:
 *
 *	Simplest SSL Server
 *
 * ABSTRACT:
 *
 *	This is an example of a SSL server with minimum functionality.
 *	The socket APIs are used to handle TCP/IP operations. This SSL
 *	server loads its own certificate and key, but it does not verify
 *	the certificate of the SSL client.
 *
 * ENVIRONMENT:
 *
 *    OpenVMS Alpha V7.2-2 or higher
 *    TCP/IP Services V5.0A or higher
 *
 * AUTHOR:
 *
 *    Taka Shinagawa, OpenVMS Security Group
 *
 * CREATION DATE:
 *
 *    1-Jan-2002
 *
 * --
 */


/* Assumptions, Build, Configuration, and Execution Instructions */

/*
 *  ASSUMPTIONS:
 *
 *    The following are assumed to be true for the
 *    execution of this program to succeed:
 *
 *    - SSL is installed and started on this system.
 *
 *    - this server program, and its accompanying client
 *      program are run on the same system, but in different
 *      processes.
 *
 *    - the certificate and keys referenced by this program
 *      reside in the same directory as this program.  There 
 *      is a command procedure, SSL$EXAMPLES_SETUP.COM, to 
 *      help set up the certificates and keys.
 *
 *
 *  BUILD INSTRUCTIONS:
 *
 *    To build this example program use commands of the form,
 *
 *      For a 32-bit application using only SSL APIs needs to run the 
 *      following commands for SSL_APP.C .
 *       -----------------------------------------------------------------
 *       $CC/POINTER_SIZE=32/PREFIX_LIBRARY_ENTRIES=ALL_ENTRIES SSL_APP.C
 *       $LINK SSL_APP.OBJ, VMS_DECC_OPTIONS.OPT/OPT
 *       -----------------------------------------------------------------
 *       VMS_DECC_OPTIONS.OPT should include the following lines.
 *       -------------------------------------------------
 *       SYS$LIBRARY:OPENSSL$LIBCRYPTO_SHR32.EXE/SHARE
 *       SYS$LIBRARY:OPENSSL$LIBSSL_SHR32.EXE/SHARE
 *       -------------------------------------------------
 *
 *       Creating a 64-bit application of SSL_APP.C should run the 
 *       following commands.
 *       -----------------------------------------------------------------
 *       $CC/POINTER_SIZE=64/PREFIX_LIBRARY_ENTRIES=ALL_ENTRIES SSL_APP.C
 *       $LINK SSL_APP.OBJ, VMS_DECC_OPTIONS.OPT/OPT
 *       -----------------------------------------------------------------
 *       VMS_DECC_OPTIONS.OPT should include the following lines.
 *       -------------------------------------------------
 *       SYS$LIBRARY:OPENSSL$LIBCRYPTO_SHR.EXE/SHARE
 *       SYS$LIBRARY:OPENSSL$LIBSSL_SHR.EXE/SHARE
 *       -------------------------------------------------
 *
 *
 * CONFIGURATION INSTRUCTIONS:
 *
 *
 * RUN INSTRUCTIONS:
 *
 *    To run this example program:
 *
 *    1) Start the server program,
 *
 *       $ run server
 *
 *    2) Start the client program on this same system,
 *
 *       $ run client
 *
 */


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <netdb.h>
#include <unistd.h>

#ifdef __VMS
#include <types.h>
#include <socket.h>
#include <in.h>
#include <inet.h>
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#endif

#include <openssl/crypto.h>
#include <openssl/ssl.h>
#include <openssl/err.h>

#define RSA_SERVER_CERT 	"server.crt"
#define RSA_SERVER_KEY 		"server.key"

#define RSA_SERVER_CA_CERT	"server_ca.crt"
#define RSA_SERVER_CA_PATH	"sys$common:[syshlp.examples.ssl]"

#define ON 	1
#define OFF 	0

#define RETURN_NULL(x) if ((x)==NULL) exit(1)
#define RETURN_ERR(err,s) if ((err)==-1) { perror(s); exit(1); }
#define RETURN_SSL(err) if ((err)==-1) { ERR_print_errors_fp(stderr); exit(1); }

void main()
{
	int 	err;
	int 	verify_client = OFF; /* To verify a client certificate, set ON */

  	int 	listen_sock;
  	int 	sock;
  	struct sockaddr_in sa_serv;
  	struct sockaddr_in sa_cli;
  	size_t client_len;
  	char	*str;
  	char     buf[4096];

	SSL_CTX		*ctx;
        SSL		*ssl;
  	SSL_METHOD 	*meth;
	X509		*client_cert = NULL;

	short int       s_port = 5555;

        /*----------------------------------------------------------------*/
	/* Load encryption & hashing algorithms for the SSL program */
	SSL_library_init();

	/* Load the error strings for SSL & CRYPTO APIs */
	SSL_load_error_strings();

	/* Create a SSL_METHOD structure (choose a SSL/TLS protocol version) */
  	meth = SSLv3_method();

	/* Create a SSL_CTX structure */
  	ctx = SSL_CTX_new(meth);
	if (!ctx) {
		ERR_print_errors_fp(stderr);
		exit(1);
	}

	/* Load the server certificate into the SSL_CTX structure */
	if (SSL_CTX_use_certificate_file(ctx, RSA_SERVER_CERT, SSL_FILETYPE_PEM) <= 0) {
    		ERR_print_errors_fp(stderr);
    		exit(1);
	}

	/* Load the private-key corresponding to the server certificate */
  	if (SSL_CTX_use_PrivateKey_file(ctx, RSA_SERVER_KEY, SSL_FILETYPE_PEM) <= 0) {
    		ERR_print_errors_fp(stderr);
    		exit(1);
  	}

	/* Check if the server certificate and private-key matches */
	if (!SSL_CTX_check_private_key(ctx)) {
    		fprintf(stderr,"Private key does not match the certificate public key\n");
    		exit(1);
  	}

	if(verify_client == ON)
	{
		/* Load the RSA CA certificate into the SSL_CTX structure */
		if (!SSL_CTX_load_verify_locations(ctx, RSA_SERVER_CA_CERT, NULL)) {
                	ERR_print_errors_fp(stderr);
                	exit(1);
        	}

		/* Set to require peer (client) certificate verification */
		SSL_CTX_set_verify(ctx,SSL_VERIFY_PEER,NULL);

		/* Set the verification depth to 1 */
		SSL_CTX_set_verify_depth(ctx,1);
	}

	/* ----------------------------------------------- */
	/* Set up a TCP socket */

	listen_sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);   
	RETURN_ERR(listen_sock, "socket");

  	memset (&sa_serv, ’\0’, sizeof(sa_serv));
  	sa_serv.sin_family      = AF_INET;
  	sa_serv.sin_addr.s_addr = INADDR_ANY;
  	sa_serv.sin_port        = htons (s_port);          /* Server Port number */
  
  	err = bind(listen_sock, (struct sockaddr*)&sa_serv,sizeof(sa_serv));
	RETURN_ERR(err, "bind");
	     
  	/* Wait for an incoming TCP connection. */
  	err = listen(listen_sock, 5);                    
	RETURN_ERR(err, "listen");

  	client_len = sizeof(sa_cli);
 
	/* Socket for a TCP/IP connection is created */
  	sock = accept(listen_sock, (struct sockaddr*)&sa_cli, &client_len);
  	RETURN_ERR(sock, "accept");
  	close (listen_sock);

  	printf ("Connection from %lx, port %x\n", sa_cli.sin_addr.s_addr, 
   sa_cli.sin_port);

	/* ----------------------------------------------- */
	/* TCP connection is ready. */

	/* A SSL structure is created */
	ssl = SSL_new(ctx);
	RETURN_NULL(ssl);

	/* Assign the socket into the SSL structure (SSL and socket without BIO) */
	SSL_set_fd(ssl, sock);

	/* Perform SSL Handshake on the SSL server */
	err = SSL_accept(ssl);
	RETURN_SSL(err);

  	/* Informational output (optional) */
  	printf("SSL connection using %s\n", SSL_get_cipher (ssl));

	if (verify_client == ON)
	{
	    /* Get the client’s certificate (optional) */
	    client_cert = SSL_get_peer_certificate(ssl);

	    if (client_cert != NULL) 
	    {
		    printf ("Client certificate:\n");
       
		    str = X509_NAME_oneline(X509_get_subject_name(client_cert), 0, 0);
		    RETURN_NULL(str);
		    printf ("\t subject: %s\n", str);
		    free (str);

		    str = X509_NAME_oneline(X509_get_issuer_name(client_cert), 0, 0);
		    RETURN_NULL(str);
		    printf ("\t issuer: %s\n", str);
		    free (str);

		    X509_free(client_cert);
	    } 
	    else
		    printf("The SSL client does not have certificate.\n");
	}


  	/*------- DATA EXCHANGE - Receive message and send reply. -------*/

	/* Receive data from the SSL client */
  	err = SSL_read(ssl, buf, sizeof(buf) - 1);
	RETURN_SSL(err);
  	buf[err] = ’\0’;
  	printf ("Received %d chars:’%s’\n", err, buf);

	/* Send data to the SSL client */
  	err = SSL_write(ssl, "This message is from the SSL server", 
   strlen("This message is from the SSL server"));
	RETURN_SSL(err);

	/*--------------- SSL closure ---------------*/
	/* Shutdown this side (server) of the connection. */
	err = SSL_shutdown(ssl);
	RETURN_SSL(err);

	/* Terminate communication on a socket */
	err = close(sock);
	RETURN_ERR(err, "close");

	/* Free the SSL structure */
	SSL_free(ssl);

	/* Free the SSL_CTX structure */
 	SSL_CTX_free(ctx);
}

$!
$!  SSL$EXAMPLES_SETUP.COM --  
$! 
$! This command procedure is actually a template that will show 
$! the commands necessary to create certificates and keys for the example
$! programs.  
$!
$! Also included in this file are the necessary options to enter into the
$! SSL$CERT_TOOL.COM to create the necessary certificates and keys to the
$! example programs.  The SSL$CERT_TOOL.COM is found in SSL$COM.  See the
$! documenation for more information about the SSL$CERT_TOOL.COM.
$!
$! 1. Create CA certificate - option 5 in SSL$CERT_TOOL.COM.
$!    This will create a key in one file, named SSL$KEY:SERVER_CA.KEY
$!    by default, and a certificate in another file, named 
$!    SSL$CRT:SERVER_CA.CRT by default.
$!
$! 2. Make 2 copies of CA certificate created in step #1.
$!    One should be called server_ca.crt and the other called 
$!    client_ca.crt as these are the filenames defined in the
$!    example programs.  You will have to exit the SSL$CERT_TOOL.COM 
$!    procedure to do this operation from the DCL command line.
$!    For example:
$!	$ COPY SSL$KEY:SERVER_CA.KEY SSL$KEY:CLIENT_CA.KEY
$!	$ COPY SSL$CRT:SERVER_CA.CRT SSL$CRT:CLIENT_CA.CRT
$!
$! 3. Create a server certificate signing request - option 3 in SSL$CERT_TOOL.COM.
$!    The Common Name should be the TCP/IP hostname of the server system.
$!    The default name of the request is SERVER.CSR.  The corresponding private
$!    key is named SERVER.KEY.
$!
$! 4. Sign server certificate signing request - option 6 in SSL$CERT_TOOL.COM
$!    Use the CA certificate, SERVER_CA.CRT, created in step #1 to sign the request 
$!    created in step #3.  This will create a certificate file, which should be 
$!    named SERVER.CRT.  This is the name as it is defined in example programs.
$!
$! 5. Create a client certificate signing request - option 3 in SSL$CERT_TOOL.COM.
$!
$! 6. Sign client certificate signing request - option 6 in SSL$CERT_TOOL.COM
$!    Use the CA certificate, CLIENT_CA.CRT, created in step #1 to sign the request 
$!    created in step #5.  This will create a certificate file, which should be 
$!    named CLIENT.CRT.  This is the name as it is defined in example programs.
$!
$! 7. These certificates and keys should reside in the same directory as
$!    the example programs.
$!
$!
$!
$!
$! The commands have been changed to use generic data as 
$! input.  To use these commands, one will have to substitute 
$! the generic data with data specific to their site.  
$! For example, yourcountry could be change to US.  It is 
$! assumed that the SSL startup file, SYS$STARTUP:SSL$STARTUP.COM, 
$! and the SSL$COM:SSL$UTILS.COM procedures have been executed.
$!
$! Set up some random data.
$!
$! $ show system/full/output=randfile.
$!
$!
$! Check to make sure the SERIAL and INDEX files exist.
$! If they don’t, create them.
$!
$! $ if f$search ("SSL$PRIVATE:SERIAL.TXT") .eqs. ""
$! $ then
$! $   CREATE SSL$PRIVATE:SERIAL.TXT
$! 01
$! $ endif
$!
$! $ if f$search ("SSL$PRIVATE:INDEX.TXT") .eqs. ""
$! $ then
$! $   CREATE SSL$PRIVATE:INDEX.TXT
$! $ endif
$!
$! Create the CA certificate.
$!
$! $ define/user sys$command sys$input
$! $ openssl req -config ssl$root:[000000]openssl-vms.cnf -new -x509 
    -days 1825 -keyout ca.key -out ca.crt
$! yourpassword
$! yourpassword
$! yourcountry
$! yourstate
$! yourcity
$! yourcompany
$! yourdepartment
$! your Certificate Authority certificate
$! firstname.lastname@yourcompany.com
$! $!
$! $!
$! $! Create the server certificate request.
$! $!
$! $!   Note : There is no way to use the value of a
$! $!          symbol when you are using the value of
$! $!          symbol as input, as we do below.  To get
$! $!          around, we create a .COM on the fly and
$! $!          execute the created .COM file to create
$! $!          the server certificate.
$! $!
$! $ hostname = f$trnlnm("tcpip$inet_host")
$! $ domain = f$trnlnm("tcpip$inet_domain")
$! $ server_name = hostname + "." + domain"
$! $!
$! $ open/write s_com create_s_cert.com
$! $! 
$! $ write s_com "$!"
$! $ write s_com "$ define/user sys$command sys$input
$! $ write s_com "$ openssl req -new -nodes -config 
     ssl$root:[000000]openssl-vms.cnf -keyout server.key -out server.csr"
$! $ write s_com "yourcountry"
$! $ write s_com "yourstate"
$! $ write s_com "yourcity"
$! $ write s_com "yourcompany"
$! $ write s_com "yourdepartment"
$! $ write s_com "’’server_name’"
$! $ write s_com "firstname.lastname@yourcompany.com"
$! $ write s_com ""
$! $ write s_com ""
$! $!
$! $ close s_com
$! $ @create_s_cert
$! $ delete create_s_cert.com;
$! $!
$! $!
$! $! Now, sign the server certificate ...
$! $!
$! $ define/user sys$command sys$input
$! $ openssl ca -config ssl$root:[000000]openssl-vms.cnf -cert 
     ca.crt -keyfile ca.key -out server.crt -infiles server.csr
$! yourpassword
$! Y
$! Y
$! $!
$! $!
$! $! Create the client certificate request.
$! $!
$! $ define/user sys$command sys$input
$! $ openssl req -new -nodes -config ssl$root:[000000]openssl-vms.cnf 
     -keyout client.key -out client.csr
$! yourcountry
$! yourstate
$! yourcity
$! yourcompany
$! yourdepartment
$! yourname
$! firstname.lastname@yourcompany.com
$! 
$! 
$! $!
$! $!
$! $! Now, sign the client certificate ...
$! $!
$! $ define/user sys$command sys$input
$! $ openssl ca -config ssl$root:[000000]openssl-vms.cnf -cert 
     ca.crt -keyfile ca.key -out client.crt -infiles client.csr
$! yourpassword
$! Y
$! Y
$! $!
$! $! Let’s view the CA certificate.
$! $!
$! $ openssl x509 -noout -text -in ca.crt
$! $!
$! $!
$! $! Let’s view the Server Certificate Request.
$! $!
$! $ openssl req -noout -text -in server.csr
$! $!
$! $! Let’s view the Server Certificate.
$! $!
$! $ openssl x509 -noout -text -in server.crt
$! $!
$! $! Let’s view the Client Certificate Request.
$! $!
$! $ openssl req -noout -text -in client.csr
$! $!
$! $! Let’s view the Client Certificate.
$! $!
$! $ openssl x509 -noout -text -in client.crt
$! $!
$! $!
$! $exit

1.2.3.4	shortName	A long name

  0:d=0  hl=4 l= 681 cons: SEQUENCE          

  .....

  229:d=3  hl=3 l= 141 prim: BIT STRING        
  373:d=2  hl=3 l= 162 cons: cont [ 3 ]        
  376:d=3  hl=3 l= 159 cons: SEQUENCE          
  379:d=4  hl=2 l=  29 cons: SEQUENCE          
  381:d=5  hl=2 l=   3 prim: OBJECT            :X509v3 Subject Key Identifier
  386:d=5  hl=2 l=  22 prim: OCTET STRING      
  410:d=4  hl=2 l= 112 cons: SEQUENCE          
  412:d=5  hl=2 l=   3 prim: OBJECT            :X509v3 Authority Key Identifier
  417:d=5  hl=2 l= 105 prim: OCTET STRING      
  524:d=4  hl=2 l=  12 cons: SEQUENCE          

  .....

0:d=0  hl=3 l= 137 cons: SEQUENCE 
3:d=1  hl=3 l= 129 prim: INTEGER   :E5D21E1F5C8D208EA7A2166C7FAF9F6BDF2059669C60876DDB70840
	F1A5AAFA59699FE471F379F1DD6A487E7D5409AB6A88D4A9746E24B91
	D8CF55DB3521015460C8EDE44EE8A4189F7A7BE77D6CD3A9AF2696F486855
	CF58BF0EDF2B4068058C7A947F52548DDF7E15E96B385F86422BEA9064A3
	EE9E1158A56E4A6F47E5897
135:d=1  hl=2 l=   3 prim: INTEGER        :010001

#include <openssl/bio.h>

#include <openssl/bio.h>

#include <openssl/bio.h>

#include <openssl/bio.h>

#include <openssl/bio.h>
#include <openssl/evp.h>

 BIO *bio, *b64;
 char message[] = "Hello World \n";

 b64 = BIO_new(BIO_f_base64());
 bio = BIO_new_fp(stdout, BIO_NOCLOSE);
 bio = BIO_push(b64, bio);
 BIO_write(bio, message, strlen(message));
 BIO_flush(bio);

 BIO_free_all(bio);

 BIO *bio, *b64, bio_out;
 char inbuf[512];
 int inlen;
 char message[] = "Hello World \n";

 b64 = BIO_new(BIO_f_base64());
 bio = BIO_new_fp(stdin, BIO_NOCLOSE);
 bio_out = BIO_new_fp(stdout, BIO_NOCLOSE);
 bio = BIO_push(b64, bio);
 while((inlen = BIO_read(bio, inbuf, strlen(message))) > 0) 
	BIO_write(bio_out, inbuf, inlen);

 BIO_free_all(bio);

#include <openssl/bio.h>

#include <openssl/bio.h>
#include <openssl/evp.h>