/ - Diff - CSE2410 Fall 2014 Bounce - CS Projects

      OpenSSL CHANGES
      _______________
      Changes between 1.0.1h and 1.0.1i [6 Aug 2014]
       *) Fix SRP buffer overrun vulnerability. Invalid parameters passed to the
          SRP code can be overrun an internal buffer. Add sanity check that
          g, A, B < N to SRP code.
          Thanks to Sean Devlin and Watson Ladd of Cryptography Services, NCC
          Group for discovering this issue.
          (CVE-2014-3512)
          [Steve Henson]
       *) A flaw in the OpenSSL SSL/TLS server code causes the server to negotiate
          TLS 1.0 instead of higher protocol versions when the ClientHello message
          is badly fragmented. This allows a man-in-the-middle attacker to force a
          downgrade to TLS 1.0 even if both the server and the client support a
          higher protocol version, by modifying the client's TLS records.
          Thanks to David Benjamin and Adam Langley (Google) for discovering and
          researching this issue.
          (CVE-2014-3511)
          [David Benjamin]
       *) OpenSSL DTLS clients enabling anonymous (EC)DH ciphersuites are subject
          to a denial of service attack. A malicious server can crash the client
          with a null pointer dereference (read) by specifying an anonymous (EC)DH
          ciphersuite and sending carefully crafted handshake messages.
          Thanks to Felix Gr?bert (Google) for discovering and researching this
          issue.
          (CVE-2014-3510)
          [Emilia K?sper]
       *) By sending carefully crafted DTLS packets an attacker could cause openssl
          to leak memory. This can be exploited through a Denial of Service attack.
          Thanks to Adam Langley for discovering and researching this issue.
          (CVE-2014-3507)
          [Adam Langley]
       *) An attacker can force openssl to consume large amounts of memory whilst
          processing DTLS handshake messages. This can be exploited through a
          Denial of Service attack.
          Thanks to Adam Langley for discovering and researching this issue.
          (CVE-2014-3506)
          [Adam Langley]
       *) An attacker can force an error condition which causes openssl to crash
          whilst processing DTLS packets due to memory being freed twice. This
          can be exploited through a Denial of Service attack.
          Thanks to Adam Langley and Wan-Teh Chang for discovering and researching
          this issue.
          (CVE-2014-3505)
          [Adam Langley]
       *) If a multithreaded client connects to a malicious server using a resumed
          session and the server sends an ec point format extension it could write
          up to 255 bytes to freed memory.
          Thanks to Gabor Tyukasz (LogMeIn Inc) for discovering and researching this
          issue.
          (CVE-2014-3509)
          [Gabor Tyukasz]
       *) A malicious server can crash an OpenSSL client with a null pointer
          dereference (read) by specifying an SRP ciphersuite even though it was not
          properly negotiated with the client. This can be exploited through a
          Denial of Service attack.
          Thanks to Joonas Kuorilehto and Riku Hietam?ki (Codenomicon) for
          discovering and researching this issue.
          (CVE-2014-5139)
          [Steve Henson]
       *) A flaw in OBJ_obj2txt may cause pretty printing functions such as
          X509_name_oneline, X509_name_print_ex et al. to leak some information
          from the stack. Applications may be affected if they echo pretty printing
          output to the attacker.
          Thanks to Ivan Fratric (Google) for discovering this issue.
          (CVE-2014-3508)
          [Emilia K?sper, and Steve Henson]
       *) Fix ec_GFp_simple_points_make_affine (thus, EC_POINTs_mul etc.)
          for corner cases. (Certain input points at infinity could lead to
          bogus results, with non-infinity inputs mapped to infinity too.)
          [Bodo Moeller]
      Changes between 1.0.1g and 1.0.1h [5 Jun 2014]
       *) Fix for SSL/TLS MITM flaw. An attacker using a carefully crafted

     		 "sctp"       => "default",
     		 "shared"         => "default",
     		 "store"	  => "experimental",
     		 "unit-test"	  => "default",
     		 "zlib"           => "default",
     		 "zlib-dynamic"   => "default"
     	       );
-...
     # This is what $depflags will look like with the above defaults
     # (we need this to see if we should advise the user to run "make depend"):
     my $default_depflags = " -DOPENSSL_NO_EC_NISTP_64_GCC_128 -DOPENSSL_NO_GMP -DOPENSSL_NO_JPAKE -DOPENSSL_NO_MD2 -DOPENSSL_NO_RC5 -DOPENSSL_NO_RFC3779 -DOPENSSL_NO_SCTP -DOPENSSL_NO_STORE";
     my $default_depflags = " -DOPENSSL_NO_EC_NISTP_64_GCC_128 -DOPENSSL_NO_GMP -DOPENSSL_NO_JPAKE -DOPENSSL_NO_MD2 -DOPENSSL_NO_RC5 -DOPENSSL_NO_RFC3779 -DOPENSSL_NO_SCTP -DOPENSSL_NO_STORE -DOPENSSL_NO_UNIT_TEST";
     # Explicit "no-..." options will be collected in %disabled along with the defaults.
     # To remove something from %disabled, use "enable-foo" (unless it's experimental).

     documentation is included in each OpenSSL distribution under the docs
     directory.
     For information on parts of libcrypto that are not yet documented, you
     might want to read Ariel Glenn's documentation on SSLeay 0.9, OpenSSL's
     predecessor, at <URL: http://www.columbia.edu/~ariel/ssleay/>.  Much
     of this still applies to OpenSSL.
     There is some documentation about certificate extensions and PKCS#12
     in doc/openssl.txt

     ## Makefile for OpenSSL
     ##
     VERSION=1.0.1h
     VERSION=1.0.1i
     MAJOR=1
     MINOR=0.1
     SHLIB_VERSION_NUMBER=1.0.0
-...
     SHLIB_MINOR=0.0
     SHLIB_EXT=
     PLATFORM=dist
     OPTIONS= no-ec_nistp_64_gcc_128 no-gmp no-jpake no-krb5 no-md2 no-rc5 no-rfc3779 no-sctp no-shared no-store no-zlib no-zlib-dynamic static-engine
     OPTIONS= no-ec_nistp_64_gcc_128 no-gmp no-jpake no-krb5 no-md2 no-rc5 no-rfc3779 no-sctp no-shared no-store no-unit-test no-zlib no-zlib-dynamic static-engine
     CONFIGURE_ARGS=dist
     SHLIB_TARGET=
-...
     CC= cc
     CFLAG= -O
     DEPFLAG= -DOPENSSL_NO_EC_NISTP_64_GCC_128 -DOPENSSL_NO_GMP -DOPENSSL_NO_JPAKE -DOPENSSL_NO_MD2 -DOPENSSL_NO_RC5 -DOPENSSL_NO_RFC3779 -DOPENSSL_NO_SCTP -DOPENSSL_NO_STORE
     DEPFLAG= -DOPENSSL_NO_EC_NISTP_64_GCC_128 -DOPENSSL_NO_GMP -DOPENSSL_NO_JPAKE -DOPENSSL_NO_MD2 -DOPENSSL_NO_RC5 -DOPENSSL_NO_RFC3779 -DOPENSSL_NO_SCTP -DOPENSSL_NO_STORE -DOPENSSL_NO_UNIT_TEST
     PEX_LIBS=
     EX_LIBS=
     EXE_EXT=

     ## Makefile for OpenSSL
     ##
     VERSION=1.0.1h-dev
     VERSION=1.0.1i-dev
     MAJOR=1
     MINOR=0.1
     SHLIB_VERSION_NUMBER=1.0.0
-...
     SHLIB_MINOR=0.0
     SHLIB_EXT=
     PLATFORM=gcc
     OPTIONS= no-ec_nistp_64_gcc_128 no-gmp no-jpake no-krb5 no-md2 no-rc5 no-rfc3779 no-sctp no-shared no-store no-zlib no-zlib-dynamic static-engine
     OPTIONS= no-ec_nistp_64_gcc_128 no-gmp no-jpake no-krb5 no-md2 no-rc5 no-rfc3779 no-sctp no-shared no-store no-unit-test no-zlib no-zlib-dynamic static-engine
     CONFIGURE_ARGS=gcc
     SHLIB_TARGET=
-...
     CC= gcc
     CFLAG= -O3
     DEPFLAG= -DOPENSSL_NO_EC_NISTP_64_GCC_128 -DOPENSSL_NO_GMP -DOPENSSL_NO_JPAKE -DOPENSSL_NO_MD2 -DOPENSSL_NO_RC5 -DOPENSSL_NO_RFC3779 -DOPENSSL_NO_SCTP -DOPENSSL_NO_STORE
     DEPFLAG= -DOPENSSL_NO_EC_NISTP_64_GCC_128 -DOPENSSL_NO_GMP -DOPENSSL_NO_JPAKE -DOPENSSL_NO_MD2 -DOPENSSL_NO_RC5 -DOPENSSL_NO_RFC3779 -DOPENSSL_NO_SCTP -DOPENSSL_NO_STORE -DOPENSSL_NO_UNIT_TEST
     PEX_LIBS=
     EX_LIBS=
     EXE_EXT=

       This file gives a brief overview of the major changes between each OpenSSL
       release. For more details please read the CHANGES file.
       Major changes between OpenSSL 1.0.1h and OpenSSL 1.0.1i [6 Aug 2014]
           o Fix for CVE-2014-3512
           o Fix for CVE-2014-3511
           o Fix for CVE-2014-3510
           o Fix for CVE-2014-3507
           o Fix for CVE-2014-3506
           o Fix for CVE-2014-3505
           o Fix for CVE-2014-3509
           o Fix for CVE-2014-5139
           o Fix for CVE-2014-3508
       Major changes between OpenSSL 1.0.1g and OpenSSL 1.0.1h [5 Jun 2014]
           o Fix for CVE-2014-0224
           o Fix for CVE-2014-0221
           o Fix for CVE-2014-0198
           o Fix for CVE-2014-0195
           o Fix for CVE-2014-3470
           o Fix for CVE-2010-5298

deps/openssl/openssl/README
1	1
2		OpenSSL 1.0.1h 5 Jun 2014
	2	OpenSSL 1.0.1i 6 Aug 2014
3	3
4	4	Copyright (c) 1998-2011 The OpenSSL Project
5	5	Copyright (c) 1995-1998 Eric A. Young, Tim J. Hudson

+    		{
     		arg->count=20;
     		arg->data=(char **)OPENSSL_malloc(sizeof(char *)*arg->count);
     		if (arg->data == NULL)
     			return 0;
+    		}
     	for (i=0; i<arg->count; i++)
     		arg->data[i]=NULL;
-...
     	len=strlen(t)+strlen(OPENSSL_CONF)+2;
     	p=OPENSSL_malloc(len);
     	if (p == NULL)
     		return NULL;
     	BUF_strlcpy(p,t,len);
     #ifndef OPENSSL_SYS_VMS
     	BUF_strlcat(p,"/",len);

+    		{
     		ok=0;
     		BIO_printf(bio_err,"Signature verification problems....\n");
     		ERR_print_errors(bio_err);
     		goto err;
+    		}
     	if (i == 0)
+    		{
     		ok=0;
     		BIO_printf(bio_err,"Signature did not match the certificate request\n");
     		ERR_print_errors(bio_err);
     		goto err;
+    		}
     	else
-...
     	revtm = X509_gmtime_adj(NULL, 0);
     	if (!revtm)
     		return NULL;
     	i = revtm->length + 1;
     	if (reason) i += strlen(reason) + 1;

     	char buf[512];
     	BIO *STDout=NULL;
     #if !defined(OPENSSL_NO_SSL2) && !defined(OPENSSL_NO_SSL3)
     	meth=SSLv23_server_method();
     #elif !defined(OPENSSL_NO_SSL3)
     	meth=SSLv3_server_method();
     #elif !defined(OPENSSL_NO_SSL2)
     	meth=SSLv2_server_method();
     #endif
     	apps_startup();

deps/openssl/openssl/apps/crl2p7.c
141	141	{
142	142	if (--argc < 1) goto bad;
143	143	if(!certflst) certflst = sk_OPENSSL_STRING_new_null();
144		sk_OPENSSL_STRING_push(certflst,*(++argv));
	144	if (!certflst)
	145	goto end;
	146	if (!sk_OPENSSL_STRING_push(certflst,*(++argv)))
	147	{
	148	sk_OPENSSL_STRING_free(certflst);
	149	goto end;
	150	}
145	151	}
146	152	else
147	153	{

     #include <openssl/x509.h>
     #include <openssl/rand.h>
     #include <openssl/pem.h>
     #ifndef OPENSSL_NO_COMP
     #include <openssl/comp.h>
     #endif
     #include <ctype.h>
     int set_hex(char *in,unsigned char *out,int size);
-...
     		goto end;
+    		}
     	if (cipher && (EVP_CIPHER_mode(cipher) == EVP_CIPH_XTS_MODE))
+    		{
     		BIO_printf(bio_err, "Ciphers in XTS mode are not supported by the enc utility\n");
     		goto end;
+    		}
     	if (md && (dgst=EVP_get_digestbyname(md)) == NULL)
+    		{
     		BIO_printf(bio_err,"%s is an unsupported message digest type\n",md);

+    		}
     	resp = query_responder(err, cbio, path, headers, req, req_timeout);
     	if (!resp)
     		BIO_printf(bio_err, "Error querying OCSP responsder\n");
     		BIO_printf(bio_err, "Error querying OCSP responder\n");
     	end:
     	if (cbio)
     		BIO_free_all(cbio);

     	{FUNC_TYPE_GENERAL,"gendsa",gendsa_main},
     #endif
     	{FUNC_TYPE_GENERAL,"genpkey",genpkey_main},
     #if !defined(OPENSSL_NO_SOCK) && !(defined(OPENSSL_NO_SSL2) && defined(OPENSSL_NO_SSL3))
     #if !defined(OPENSSL_NO_SOCK)
     	{FUNC_TYPE_GENERAL,"s_server",s_server_main},
     #endif
     #if !defined(OPENSSL_NO_SOCK) && !(defined(OPENSSL_NO_SSL2) && defined(OPENSSL_NO_SSL3))
     #if !defined(OPENSSL_NO_SOCK)
     	{FUNC_TYPE_GENERAL,"s_client",s_client_main},
     #endif
     #ifndef OPENSSL_NO_SPEED
     	{FUNC_TYPE_GENERAL,"speed",speed_main},
     #endif
     #if !defined(OPENSSL_NO_SOCK) && !(defined(OPENSSL_NO_SSL2) && defined(OPENSSL_NO_SSL3))
     #if !defined(OPENSSL_NO_SOCK)
     	{FUNC_TYPE_GENERAL,"s_time",s_time_main},
     #endif
     	{FUNC_TYPE_GENERAL,"version",version_main},
-...
     #endif
     	{FUNC_TYPE_GENERAL,"crl2pkcs7",crl2pkcs7_main},
     	{FUNC_TYPE_GENERAL,"sess_id",sess_id_main},
     #if !defined(OPENSSL_NO_SOCK) && !(defined(OPENSSL_NO_SSL2) && defined(OPENSSL_NO_SSL3))
     #if !defined(OPENSSL_NO_SOCK)
     	{FUNC_TYPE_GENERAL,"ciphers",ciphers_main},
     #endif
     	{FUNC_TYPE_GENERAL,"nseq",nseq_main},

     	push(@files,$_);
     	$str="\t{FUNC_TYPE_GENERAL,\"$_\",${_}_main},\n";
     	if (($_ =~ /^s_/) || ($_ =~ /^ciphers$/))
     		{ print "#if !defined(OPENSSL_NO_SOCK) && !(defined(OPENSSL_NO_SSL2) && defined(OPENSSL_NO_SSL3))\n${str}#endif\n"; }
     		{ print "#if !defined(OPENSSL_NO_SOCK)\n${str}#endif\n"; }
     	elsif ( ($_ =~ /^speed$/))
     		{ print "#ifndef OPENSSL_NO_SPEED\n${str}#endif\n"; }
     	elsif ( ($_ =~ /^engine$/))

     #include <fcntl.h>
     #endif
     /* Use Windows API with STD_INPUT_HANDLE when checking for input?
        Don't look at OPENSSL_SYS_MSDOS for this, since it is always defined if
        OPENSSL_SYS_WINDOWS is defined */
     #if defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_WINCE) && defined(STD_INPUT_HANDLE)
     #define OPENSSL_USE_STD_INPUT_HANDLE
     #endif
     #undef PROG
     #define PROG	s_client_main
-...
     	BIO_printf(bio_err," -connect host:port - who to connect to (default is %s:%s)\n",SSL_HOST_NAME,PORT_STR);
     	BIO_printf(bio_err," -verify arg   - turn on peer certificate verification\n");
     	BIO_printf(bio_err," -verify_return_error - return verification errors\n");
     	BIO_printf(bio_err," -cert arg     - certificate file to use, PEM format assumed\n");
     	BIO_printf(bio_err," -certform arg - certificate format (PEM or DER) PEM default\n");
     	BIO_printf(bio_err," -key arg      - Private key file to use, in cert file if\n");
-...
     	BIO_printf(bio_err," -CAfile arg   - PEM format file of CA's\n");
     	BIO_printf(bio_err," -reconnect    - Drop and re-make the connection with the same Session-ID\n");
     	BIO_printf(bio_err," -pause        - sleep(1) after each read(2) and write(2) system call\n");
     	BIO_printf(bio_err," -prexit       - print session information even on connection failure\n");
     	BIO_printf(bio_err," -showcerts    - show all certificates in the chain\n");
     	BIO_printf(bio_err," -debug        - extra output\n");
     #ifdef WATT32
-...
     					tv.tv_usec = 0;
     					i=select(width,(void *)&readfds,(void *)&writefds,
     						 NULL,&tv);
     #if defined(OPENSSL_USE_STD_INPUT_HANDLE)
     					if(!i && (!((_kbhit()) || (WAIT_OBJECT_0 == WaitForSingleObject(GetStdHandle(STD_INPUT_HANDLE), 0))) || !read_tty) ) continue;
     #else
     #if defined(OPENSSL_SYS_WINCE) || defined(OPENSSL_SYS_MSDOS)
     					if(!i && (!_kbhit() || !read_tty) ) continue;
     #else
     					if(!i && (!((_kbhit()) || (WAIT_OBJECT_0 == WaitForSingleObject(GetStdHandle(STD_INPUT_HANDLE), 0))) || !read_tty) ) continue;
     #endif
     				} else 	i=select(width,(void *)&readfds,(void *)&writefds,
     					 NULL,timeoutp);
-...
+    			}
     #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS)
     #if defined(OPENSSL_USE_STD_INPUT_HANDLE)
     		else if ((_kbhit()) || (WAIT_OBJECT_0 == WaitForSingleObject(GetStdHandle(STD_INPUT_HANDLE), 0)))
     #else
     #if defined(OPENSSL_SYS_WINCE) || defined(OPENSSL_SYS_MSDOS)
     		else if (_kbhit())
     #else
     		else if ((_kbhit()) || (WAIT_OBJECT_0 == WaitForSingleObject(GetStdHandle(STD_INPUT_HANDLE), 0)))
     #endif
     #elif defined (OPENSSL_SYS_NETWARE)
     		else if (_kbhit())

     	BIO_printf(bio_err," -context arg  - set session ID context\n");
     	BIO_printf(bio_err," -verify arg   - turn on peer certificate verification\n");
     	BIO_printf(bio_err," -Verify arg   - turn on peer certificate verification, must have a cert.\n");
     	BIO_printf(bio_err," -verify_return_error - return verification errors\n");
     	BIO_printf(bio_err," -cert arg     - certificate file to use\n");
     	BIO_printf(bio_err,"                 (default is %s)\n",TEST_CERT);
     	BIO_printf(bio_err," -crl_check    - check the peer certificate has not been revoked by its CA.\n" \
-...
     	BIO_printf(bio_err," -no_ecdhe     - Disable ephemeral ECDH\n");
     #endif
     	BIO_printf(bio_err," -bugs         - Turn on SSL bug compatibility\n");
     	BIO_printf(bio_err," -hack         - workaround for early Netscape code\n");
     	BIO_printf(bio_err," -www          - Respond to a 'GET /' with a status page\n");
     	BIO_printf(bio_err," -WWW          - Respond to a 'GET /<path> HTTP/1.0' with file ./<path>\n");
     	BIO_printf(bio_err," -HTTP         - Respond to a 'GET /<path> HTTP/1.0' with file ./<path>\n");
-...
     #endif
     	BIO_printf(bio_err," -keymatexport label   - Export keying material using label\n");
     	BIO_printf(bio_err," -keymatexportlen len  - Export len bytes of keying material (default 20)\n");
     	BIO_printf(bio_err," -status           - respond to certificate status requests\n");
     	BIO_printf(bio_err," -status_verbose   - enable status request verbose printout\n");
     	BIO_printf(bio_err," -status_timeout n - status request responder timeout\n");
     	BIO_printf(bio_err," -status_url URL   - status request fallback URL\n");
+    	}
     static int local_argc=0;
-...
     	if (servername)
+    		{
         		if (strcmp(servername,p->servername))
         		if (strcasecmp(servername,p->servername))
     			return p->extension_error;
     		if (ctx2)
+    			{
-...
     		sv_usage();
     		goto end;
+    		}
     #ifndef OPENSSL_NO_DTLS1
     	if (www && socket_type == SOCK_DGRAM)
+    		{
     		BIO_printf(bio_err,
     				"Can't use -HTTP, -www or -WWW with DTLS\n");
     		goto end;
+    		}
     #endif
     #if !defined(OPENSSL_NO_JPAKE) && !defined(OPENSSL_NO_PSK)
     	if (jpake_secret)

     	ASN1err(ASN1_F_D2I_ASN1_OBJECT,i);
     	return(NULL);
+    }
     ASN1_OBJECT *c2i_ASN1_OBJECT(ASN1_OBJECT **a, const unsigned char **pp,
     	     long len)
+    	{
     	ASN1_OBJECT *ret=NULL;
     	const unsigned char *p;
     	unsigned char *data;
     	int i;
     	/* Sanity check OID encoding: can't have leading 0x80 in
     	 * subidentifiers, see: X.690 8.19.2
     	int i, length;
     	/* Sanity check OID encoding.
     	 * Need at least one content octet.
     	 * MSB must be clear in the last octet.
     	 * can't have leading 0x80 in subidentifiers, see: X.690 8.19.2
     	 */
     	for (i = 0, p = *pp; i < len; i++, p++)
     	if (len <= 0 || len > INT_MAX || pp == NULL || (p = *pp) == NULL ||
     	    p[len - 1] & 0x80)
+    		{
     		ASN1err(ASN1_F_C2I_ASN1_OBJECT,ASN1_R_INVALID_OBJECT_ENCODING);
     		return NULL;
+    		}
     	/* Now 0 < len <= INT_MAX, so the cast is safe. */
     	length = (int)len;
     	for (i = 0; i < length; i++, p++)
+    		{
     		if (*p == 0x80 && (!i || !(p[-1] & 0x80)))
+    			{
-...
     	data = (unsigned char *)ret->data;
     	ret->data = NULL;
     	/* once detached we can change it */
     	if ((data == NULL) || (ret->length < len))
     	if ((data == NULL) || (ret->length < length))
+    		{
     		ret->length=0;
     		if (data != NULL) OPENSSL_free(data);
     		data=(unsigned char *)OPENSSL_malloc(len ? (int)len : 1);
     		data=(unsigned char *)OPENSSL_malloc(length);
     		if (data == NULL)
     			{ i=ERR_R_MALLOC_FAILURE; goto err; }
     		ret->flags|=ASN1_OBJECT_FLAG_DYNAMIC_DATA;
+    		}
     	memcpy(data,p,(int)len);
     	memcpy(data,p,length);
     	/* reattach data to object, after which it remains const */
     	ret->data  =data;
     	ret->length=(int)len;
     	ret->length=length;
     	ret->sn=NULL;
     	ret->ln=NULL;
     	/* ret->flags=ASN1_OBJECT_FLAG_DYNAMIC; we know it is dynamic */
     	p+=len;
     	p+=length;
     	if (a != NULL) (*a)=ret;
     	*pp=p;

     	struct tm *ts;
     	struct tm data;
     	size_t len = 20;
     	int free_s = 0;
     	if (s == NULL)
+    		{
     		free_s = 1;
     		s=M_ASN1_UTCTIME_new();
+    		}
     	if (s == NULL)
     		return(NULL);
     		goto err;
     	ts=OPENSSL_gmtime(&t, &data);
     	if (ts == NULL)
     		return(NULL);
     		goto err;
     	if (offset_day || offset_sec)
+    		{
     		if (!OPENSSL_gmtime_adj(ts, offset_day, offset_sec))
     			return NULL;
     			goto err;
+    		}
     	if((ts->tm_year < 50) || (ts->tm_year >= 150))
     		return NULL;
     		goto err;
     	p=(char *)s->data;
     	if ((p == NULL) || ((size_t)s->length < len))
-...
     		if (p == NULL)
+    			{
     			ASN1err(ASN1_F_ASN1_UTCTIME_ADJ,ERR_R_MALLOC_FAILURE);
     			return(NULL);
     			goto err;
+    			}
     		if (s->data != NULL)
     			OPENSSL_free(s->data);
-...
     	ebcdic2ascii(s->data, s->data, s->length);
     #endif
     	return(s);
     	err:
     	if (free_s && s)
     		M_ASN1_UTCTIME_free(s);
     	return NULL;
+    	}
-...
     	t -= offset*60; /* FIXME: may overflow in extreme cases */
     	tm = OPENSSL_gmtime(&t, &data);
     	/* NB: -1, 0, 1 already valid return values so use -2 to
     	 * indicate error.
     	 */
     	if (tm == NULL)
     		return -2;
     #define return_cmp(a,b) if ((a)<(b)) return -1; else if ((a)>(b)) return 1
     	year = g2(s->data);

     	if (!ameth)
     		return 0;
     	ameth->pkey_base_id = to;
     	return EVP_PKEY_asn1_add0(ameth);
     	if (!EVP_PKEY_asn1_add0(ameth))
+    		{
     		EVP_PKEY_asn1_free(ameth);
     		return 0;
+    		}
     	return 1;
+    	}
     int EVP_PKEY_asn1_get0_info(int *ppkey_id, int *ppkey_base_id, int *ppkey_flags,

     	*pclass=xclass;
     	if (!asn1_get_length(&p,&inf,plength,(int)max)) goto err;
     	if (inf && !(ret & V_ASN1_CONSTRUCTED))
     		goto err;
     #if 0
     	fprintf(stderr,"p=%d + *plength=%ld > omax=%ld + *pp=%d  (%d > %d)\n",
     		(int)p,*plength,omax,(int)*pp,(int)(p+ *plength),

     	int len, state, save_state = 0;
     	headers = sk_MIME_HEADER_new(mime_hdr_cmp);
     	if (!headers)
     		return NULL;
     	while ((len = BIO_gets(bio, linebuf, MAX_SMLEN)) > 0) {
     	/* If whitespace at line start then continuation line */
     	if(mhdr && isspace((unsigned char)linebuf[0])) state = MIME_NAME;

     	if (!(octmp->length = i2d(obj, NULL))) {
     		ASN1err(ASN1_F_ASN1_PACK_STRING,ASN1_R_ENCODE_ERROR);
     		return NULL;
     		goto err;
+    	}
     	if (!(p = OPENSSL_malloc (octmp->length))) {
     		ASN1err(ASN1_F_ASN1_PACK_STRING,ERR_R_MALLOC_FAILURE);
     		return NULL;
     		goto err;
+    	}
     	octmp->data = p;
     	i2d (obj, &p);
     	return octmp;
     	err:
     	if (!oct || !*oct)
+    		{
     		ASN1_STRING_free(octmp);
     		if (oct)
     			*oct = NULL;
+    		}
     	return NULL;
+    }
     #endif

     	if (!ctx)
     		return 0;
     	if (!asn1_bio_init(ctx, DEFAULT_ASN1_BUF_SIZE))
+    		{
     		OPENSSL_free(ctx);
     		return 0;
+    		}
     	b->init = 1;
     	b->ptr = (char *)ctx;
     	b->flags = 0;

     #!/usr/local/bin/perl -w
     # Written by Dr Stephen N Henson (steve@openssl.org).
     # Licensed under the terms of the OpenSSL license.
     use strict;
     my ($i, @arr);

     	ASN1_STRING *os;
     	if ((os=M_ASN1_OCTET_STRING_new()) == NULL) return(0);
     	if (!M_ASN1_OCTET_STRING_set(os,data,len)) return(0);
     	if (!M_ASN1_OCTET_STRING_set(os,data,len))
+    		{
     		M_ASN1_OCTET_STRING_free(os);
     		return 0;
+    		}
     	ASN1_TYPE_set(a,V_ASN1_OCTET_STRING,os);
     	return(1);
+    	}

     	l=80-2-obase;
     	b=X509_NAME_oneline(name,NULL,0);
     	if (!b)
     		return 0;
     	if (!*b)
+    		{
     		OPENSSL_free(b);

+    			{
     			derlst = OPENSSL_malloc(sk_ASN1_VALUE_num(sk)
     						* sizeof(*derlst));
     			if (!derlst)
     				return 0;
     			tmpdat = OPENSSL_malloc(skcontlen);
     			if (!derlst || !tmpdat)
     			if (!tmpdat)
+    				{
     				OPENSSL_free(derlst);
     				return 0;
+    				}
+    			}
+    		}
     	/* If not sorting just output each item */

deps/openssl/openssl/crypto/asn1/x_crl.c
270	270	{
271	271	/* We handle IDP and deltas */
272	272	if ((nid == NID_issuing_distribution_point)
	273	\|\| (nid == NID_authority_key_identifier)
273	274	\|\| (nid == NID_delta_crl))
274	275	break;;
275	276	crl->flags \|= EXFLAG_CRITICAL;

     	CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, a, &a->ex_data);
     	if ((a->method == NULL) || (a->method->destroy == NULL)) return(1);
     	a->method->destroy(a);
     	if ((a->method != NULL) && (a->method->destroy != NULL))
     		a->method->destroy(a);
     	OPENSSL_free(a);
     	return(1);
+    	}

     		BNerr(BN_F_BN_EXPAND_INTERNAL,ERR_R_MALLOC_FAILURE);
     		return(NULL);
+    		}
     #ifdef PURIFY
     	/* Valgrind complains in BN_consttime_swap because we process the whole
     	 * array even if it's not initialised yet. This doesn't matter in that
     	 * function - what's important is constant time operation (we're not
     	 * actually going to use the data)
     	*/
     	memset(a, 0, sizeof(BN_ULONG)*words);
     #endif
     #if 1
     	B=b->d;
     	/* Check if the previous number needs to be copied */

deps/openssl/openssl/crypto/bn/bn_sqr.c
77	77	if (al <= 0)
78	78	{
79	79	r->top=0;
	80	r->neg = 0;
80	81	return 1;
81	82	}
82	83

     	X509_ALGOR *encalg = NULL;
     	unsigned char iv[EVP_MAX_IV_LENGTH];
     	int ivlen;
     	env = cms_get0_enveloped(cms);
     	if (!env)
     		goto err;
     		return NULL;
     	if (wrap_nid <= 0)
     		wrap_nid = NID_id_alg_PWRI_KEK;

deps/openssl/openssl/crypto/conf/conf_def.c
321	321	p=eat_ws(conf, end);
322	322	if (*p != ']')
323	323	{
324		if (*p != '\0')
	324	if (*p != '\0' && ss != p)
325	325	{
326	326	ss=p;
327	327	goto again;

deps/openssl/openssl/crypto/ec/ec_lib.c
942	942
943	943	int EC_POINT_invert(const EC_GROUP group, EC_POINT a, BN_CTX *ctx)
944	944	{
945		if (group->meth->dbl == 0)
	945	if (group->meth->invert == 0)
946	946	{
947	947	ECerr(EC_F_EC_POINT_INVERT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
948	948	return 0;

     int ec_GFp_simple_points_make_affine(const EC_GROUP *group, size_t num, EC_POINT *points[], BN_CTX *ctx)
+    	{
     	BN_CTX *new_ctx = NULL;
     	BIGNUM *tmp0, *tmp1;
     	size_t pow2 = 0;
     	BIGNUM **heap = NULL;
     	BIGNUM *tmp, *tmp_Z;
     	BIGNUM **prod_Z = NULL;
     	size_t i;
     	int ret = 0;
-...
+    		}
     	BN_CTX_start(ctx);
     	tmp0 = BN_CTX_get(ctx);
     	tmp1 = BN_CTX_get(ctx);
     	if (tmp0  == NULL || tmp1 == NULL) goto err;
     	tmp = BN_CTX_get(ctx);
     	tmp_Z = BN_CTX_get(ctx);
     	if (tmp == NULL || tmp_Z == NULL) goto err;
     	/* Before converting the individual points, compute inverses of all Z values.
     	 * Modular inversion is rather slow, but luckily we can do with a single
     	 * explicit inversion, plus about 3 multiplications per input value.
     	 */
     	prod_Z = OPENSSL_malloc(num * sizeof prod_Z[0]);
     	if (prod_Z == NULL) goto err;
     	for (i = 0; i < num; i++)
+    		{
     		prod_Z[i] = BN_new();
     		if (prod_Z[i] == NULL) goto err;
+    		}
     	pow2 = 1;
     	while (num > pow2)
     		pow2 <<= 1;
     	/* Now pow2 is the smallest power of 2 satifsying pow2 >= num.
     	 * We need twice that. */
     	pow2 <<= 1;
     	/* Set each prod_Z[i] to the product of points[0]->Z .. points[i]->Z,
     	 * skipping any zero-valued inputs (pretend that they're 1). */
     	heap = OPENSSL_malloc(pow2 * sizeof heap[0]);
     	if (heap == NULL) goto err;
     	/* The array is used as a binary tree, exactly as in heapsort:
+    	 *
     	 *                               heap[1]
     	 *                 heap[2]                     heap[3]
     	 *          heap[4]       heap[5]       heap[6]       heap[7]
     	 *   heap[8]heap[9] heap[10]heap[11] heap[12]heap[13] heap[14] heap[15]
+    	 *
     	 * We put the Z's in the last line;
     	 * then we set each other node to the product of its two child-nodes (where
     	 * empty or 0 entries are treated as ones);
     	 * then we invert heap[1];
     	 * then we invert each other node by replacing it by the product of its
     	 * parent (after inversion) and its sibling (before inversion).
     	 */
     	heap[0] = NULL;
     	for (i = pow2/2 - 1; i > 0; i--)
     		heap[i] = NULL;
     	for (i = 0; i < num; i++)
     		heap[pow2/2 + i] = &points[i]->Z;
     	for (i = pow2/2 + num; i < pow2; i++)
     		heap[i] = NULL;
     	/* set each node to the product of its children */
     	for (i = pow2/2 - 1; i > 0; i--)
     	if (!BN_is_zero(&points[0]->Z))
+    		{
     		heap[i] = BN_new();
     		if (heap[i] == NULL) goto err;
     		if (heap[2*i] != NULL)
     		if (!BN_copy(prod_Z[0], &points[0]->Z)) goto err;
+    		}
     	else
+    		{
     		if (group->meth->field_set_to_one != 0)
+    			{
     			if ((heap[2*i + 1] == NULL) || BN_is_zero(heap[2*i + 1]))
+    				{
     				if (!BN_copy(heap[i], heap[2*i])) goto err;
+    				}
     			else
+    				{
     				if (BN_is_zero(heap[2*i]))
+    					{
     					if (!BN_copy(heap[i], heap[2*i + 1])) goto err;
+    					}
     				else
+    					{
     					if (!group->meth->field_mul(group, heap[i],
     						heap[2*i], heap[2*i + 1], ctx)) goto err;
+    					}
+    				}
     			if (!group->meth->field_set_to_one(group, prod_Z[0], ctx)) goto err;
+    			}
     		else
+    			{
     			if (!BN_one(prod_Z[0])) goto err;
+    			}
+    		}
     	/* invert heap[1] */
     	if (!BN_is_zero(heap[1]))
     	for (i = 1; i < num; i++)
+    		{
     		if (!BN_mod_inverse(heap[1], heap[1], &group->field, ctx))
     		if (!BN_is_zero(&points[i]->Z))
+    			{
     			ECerr(EC_F_EC_GFP_SIMPLE_POINTS_MAKE_AFFINE, ERR_R_BN_LIB);
     			goto err;
     			if (!group->meth->field_mul(group, prod_Z[i], prod_Z[i - 1], &points[i]->Z, ctx)) goto err;
+    			}
     		else
+    			{
     			if (!BN_copy(prod_Z[i], prod_Z[i - 1])) goto err;
+    			}
+    		}
     	/* Now use a single explicit inversion to replace every
     	 * non-zero points[i]->Z by its inverse. */
     	if (!BN_mod_inverse(tmp, prod_Z[num - 1], &group->field, ctx))
+    		{
     		ECerr(EC_F_EC_GFP_SIMPLE_POINTS_MAKE_AFFINE, ERR_R_BN_LIB);
     		goto err;
+    		}
     	if (group->meth->field_encode != 0)
+    		{
     		/* in the Montgomery case, we just turned  R*H  (representing H)
     		/* In the Montgomery case, we just turned  R*H  (representing H)
     		 * into  1/(R*H),  but we need  R*(1/H)  (representing 1/H);
     		 * i.e. we have need to multiply by the Montgomery factor twice */
     		if (!group->meth->field_encode(group, heap[1], heap[1], ctx)) goto err;
     		if (!group->meth->field_encode(group, heap[1], heap[1], ctx)) goto err;
     		 * i.e. we need to multiply by the Montgomery factor twice. */
     		if (!group->meth->field_encode(group, tmp, tmp, ctx)) goto err;
     		if (!group->meth->field_encode(group, tmp, tmp, ctx)) goto err;
+    		}
     	/* set other heap[i]'s to their inverses */
     	for (i = 2; i < pow2/2 + num; i += 2)
     	for (i = num - 1; i > 0; --i)
+    		{
     		/* i is even */
     		if ((heap[i + 1] != NULL) && !BN_is_zero(heap[i + 1]))
+    			{
     			if (!group->meth->field_mul(group, tmp0, heap[i/2], heap[i + 1], ctx)) goto err;
     			if (!group->meth->field_mul(group, tmp1, heap[i/2], heap[i], ctx)) goto err;
     			if (!BN_copy(heap[i], tmp0)) goto err;
     			if (!BN_copy(heap[i + 1], tmp1)) goto err;
+    			}
     		else
     		/* Loop invariant: tmp is the product of the inverses of
     		 * points[0]->Z .. points[i]->Z (zero-valued inputs skipped). */
     		if (!BN_is_zero(&points[i]->Z))
+    			{
     			if (!BN_copy(heap[i], heap[i/2])) goto err;
     			/* Set tmp_Z to the inverse of points[i]->Z (as product
     			 * of Z inverses 0 .. i, Z values 0 .. i - 1). */
     			if (!group->meth->field_mul(group, tmp_Z, prod_Z[i - 1], tmp, ctx)) goto err;
     			/* Update tmp to satisfy the loop invariant for i - 1. */
     			if (!group->meth->field_mul(group, tmp, tmp, &points[i]->Z, ctx)) goto err;
     			/* Replace points[i]->Z by its inverse. */
     			if (!BN_copy(&points[i]->Z, tmp_Z)) goto err;
+    			}
+    		}
     	/* we have replaced all non-zero Z's by their inverses, now fix up all the points */
     	if (!BN_is_zero(&points[0]->Z))
+    		{
     		/* Replace points[0]->Z by its inverse. */
     		if (!BN_copy(&points[0]->Z, tmp)) goto err;
+    		}
     	/* Finally, fix up the X and Y coordinates for all points. */
     	for (i = 0; i < num; i++)
+    		{
     		EC_POINT *p = points[i];
     		if (!BN_is_zero(&p->Z))
+    			{
     			/* turn  (X, Y, 1/Z)  into  (X/Z^2, Y/Z^3, 1) */
     			if (!group->meth->field_sqr(group, tmp1, &p->Z, ctx)) goto err;
     			if (!group->meth->field_mul(group, &p->X, &p->X, tmp1, ctx)) goto err;
     			if (!group->meth->field_sqr(group, tmp, &p->Z, ctx)) goto err;
     			if (!group->meth->field_mul(group, &p->X, &p->X, tmp, ctx)) goto err;
     			if (!group->meth->field_mul(group, tmp, tmp, &p->Z, ctx)) goto err;
     			if (!group->meth->field_mul(group, &p->Y, &p->Y, tmp, ctx)) goto err;
     			if (!group->meth->field_mul(group, tmp1, tmp1, &p->Z, ctx)) goto err;
     			if (!group->meth->field_mul(group, &p->Y, &p->Y, tmp1, ctx)) goto err;
     			if (group->meth->field_set_to_one != 0)
+    				{
     				if (!group->meth->field_set_to_one(group, &p->Z, ctx)) goto err;
-...
+    		}
     	ret = 1;
      err:
     	BN_CTX_end(ctx);
     	if (new_ctx != NULL)
     		BN_CTX_free(new_ctx);
     	if (heap != NULL)
     	if (prod_Z != NULL)
+    		{
     		/* heap[pow2/2] .. heap[pow2-1] have not been allocated locally! */
     		for (i = pow2/2 - 1; i > 0; i--)
     		for (i = 0; i < num; i++)
+    			{
     			if (heap[i] != NULL)
     				BN_clear_free(heap[i]);
     			if (prod_Z[i] != NULL)
     				BN_clear_free(prod_Z[i]);
+    			}
     		OPENSSL_free(heap);
     		OPENSSL_free(prod_Z);
+    		}
     	return ret;
+    	}

     	EC_POINT *P = EC_POINT_new(group);
     	EC_POINT *Q = EC_POINT_new(group);
     	BN_CTX *ctx = BN_CTX_new();
     	int i;
     	n1 = BN_new(); n2 = BN_new(); order = BN_new();
     	fprintf(stdout, "verify group order ...");
-...
     	if (!EC_POINT_mul(group, Q, order, NULL, NULL, ctx)) ABORT;
     	if (!EC_POINT_is_at_infinity(group, Q)) ABORT;
     	fprintf(stdout, " ok\n");
     	fprintf(stdout, "long/negative scalar tests ... ");
     	if (!BN_one(n1)) ABORT;
     	/* n1 = 1 - order */
     	if (!BN_sub(n1, n1, order)) ABORT;
     	if(!EC_POINT_mul(group, Q, NULL, P, n1, ctx)) ABORT;
     	if (0 != EC_POINT_cmp(group, Q, P, ctx)) ABORT;
     	/* n2 = 1 + order */
     	if (!BN_add(n2, order, BN_value_one())) ABORT;
     	if(!EC_POINT_mul(group, Q, NULL, P, n2, ctx)) ABORT;
     	if (0 != EC_POINT_cmp(group, Q, P, ctx)) ABORT;
     	/* n2 = (1 - order) * (1 + order) */
     	if (!BN_mul(n2, n1, n2, ctx)) ABORT;
     	if(!EC_POINT_mul(group, Q, NULL, P, n2, ctx)) ABORT;
     	if (0 != EC_POINT_cmp(group, Q, P, ctx)) ABORT;
     	fprintf(stdout, "long/negative scalar tests ");
             for (i = 1; i <= 2; i++)
+    		{
     		const BIGNUM *scalars[6];
     		const EC_POINT *points[6];
     		fprintf(stdout, i == 1 ?
     			"allowing precomputation ... " :
     			"without precomputation ... ");
     		if (!BN_set_word(n1, i)) ABORT;
     		/* If i == 1, P will be the predefined generator for which
     		 * EC_GROUP_precompute_mult has set up precomputation. */
     		if (!EC_POINT_mul(group, P, n1, NULL, NULL, ctx)) ABORT;
     		if (!BN_one(n1)) ABORT;
     		/* n1 = 1 - order */
     		if (!BN_sub(n1, n1, order)) ABORT;
     		if (!EC_POINT_mul(group, Q, NULL, P, n1, ctx)) ABORT;
     		if (0 != EC_POINT_cmp(group, Q, P, ctx)) ABORT;
     		/* n2 = 1 + order */
     		if (!BN_add(n2, order, BN_value_one())) ABORT;
     		if (!EC_POINT_mul(group, Q, NULL, P, n2, ctx)) ABORT;
     		if (0 != EC_POINT_cmp(group, Q, P, ctx)) ABORT;
     		/* n2 = (1 - order) * (1 + order) = 1 - order^2 */
     		if (!BN_mul(n2, n1, n2, ctx)) ABORT;
     		if (!EC_POINT_mul(group, Q, NULL, P, n2, ctx)) ABORT;
     		if (0 != EC_POINT_cmp(group, Q, P, ctx)) ABORT;
     		/* n2 = order^2 - 1 */
     		BN_set_negative(n2, 0);
     		if (!EC_POINT_mul(group, Q, NULL, P, n2, ctx)) ABORT;
     		/* Add P to verify the result. */
     		if (!EC_POINT_add(group, Q, Q, P, ctx)) ABORT;
     		if (!EC_POINT_is_at_infinity(group, Q)) ABORT;
     		/* Exercise EC_POINTs_mul, including corner cases. */
     		scalars[0] = n1; points[0] = Q; /* => infinity */
     		scalars[1] = n2; points[1] = P; /* => -P */
     		scalars[2] = n1; points[2] = Q; /* => infinity */
     		scalars[3] = n2; points[3] = Q; /* => infinity */
     		scalars[4] = n1; points[4] = P; /* => P */
     		scalars[5] = n2; points[5] = Q; /* => infinity */
     		if (!EC_POINTs_mul(group, Q, NULL, 5, points, scalars, ctx)) ABORT;
     		if (!EC_POINT_is_at_infinity(group, Q)) ABORT;
+    		}
     	fprintf(stdout, "ok\n");
     	EC_POINT_free(P);
     	EC_POINT_free(Q);
     	BN_free(n1);

     		/* Extra padding: tag appended to record */
     		return EVP_GCM_TLS_TAG_LEN;
     	case EVP_CTRL_COPY:
+    		{
     			EVP_CIPHER_CTX *out = ptr;
     			EVP_AES_GCM_CTX *gctx_out = out->cipher_data;
     			if (gctx->gcm.key)
+    				{
     				if (gctx->gcm.key != &gctx->ks)
     					return 0;
     				gctx_out->gcm.key = &gctx_out->ks;
+    				}
     			if (gctx->iv == c->iv)
     				gctx_out->iv = out->iv;
     			else
+    			{
     				gctx_out->iv = OPENSSL_malloc(gctx->ivlen);
     				if (!gctx_out->iv)
     					return 0;
     				memcpy(gctx_out->iv, gctx->iv, gctx->ivlen);
+    			}
     			return 1;
+    		}
     	default:
     		return -1;
-...
     #define CUSTOM_FLAGS	(EVP_CIPH_FLAG_DEFAULT_ASN1 \
     		| EVP_CIPH_CUSTOM_IV | EVP_CIPH_FLAG_CUSTOM_CIPHER \
     		| EVP_CIPH_ALWAYS_CALL_INIT | EVP_CIPH_CTRL_INIT)
     		| EVP_CIPH_ALWAYS_CALL_INIT | EVP_CIPH_CTRL_INIT \
     		| EVP_CIPH_CUSTOM_COPY)
     BLOCK_CIPHER_custom(NID_aes,128,1,12,gcm,GCM,
     		EVP_CIPH_FLAG_FIPS|EVP_CIPH_FLAG_AEAD_CIPHER|CUSTOM_FLAGS)
-...
     static int aes_xts_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr)
+    	{
     	EVP_AES_XTS_CTX *xctx = c->cipher_data;
     	if (type != EVP_CTRL_INIT)
     	if (type == EVP_CTRL_COPY)
+    		{
     		EVP_CIPHER_CTX *out = ptr;
     		EVP_AES_XTS_CTX *xctx_out = out->cipher_data;
     		if (xctx->xts.key1)
+    			{
     			if (xctx->xts.key1 != &xctx->ks1)
     				return 0;
     			xctx_out->xts.key1 = &xctx_out->ks1;
+    			}
     		if (xctx->xts.key2)
+    			{
     			if (xctx->xts.key2 != &xctx->ks2)
     				return 0;
     			xctx_out->xts.key2 = &xctx_out->ks2;
+    			}
     		return 1;
+    		}
     	else if (type != EVP_CTRL_INIT)
     		return -1;
     	/* key1 and key2 are used as an indicator both key and IV are set */
     	xctx->xts.key1 = NULL;
-...
     #define aes_xts_cleanup NULL
     #define XTS_FLAGS	(EVP_CIPH_FLAG_DEFAULT_ASN1 | EVP_CIPH_CUSTOM_IV \
     			 | EVP_CIPH_ALWAYS_CALL_INIT | EVP_CIPH_CTRL_INIT)
     			 | EVP_CIPH_ALWAYS_CALL_INIT | EVP_CIPH_CTRL_INIT \
     			 | EVP_CIPH_CUSTOM_COPY)
     BLOCK_CIPHER_custom(NID_aes,128,1,16,xts,XTS,EVP_CIPH_FLAG_FIPS|XTS_FLAGS)
     BLOCK_CIPHER_custom(NID_aes,256,1,16,xts,XTS,EVP_CIPH_FLAG_FIPS|XTS_FLAGS)
-...
     		cctx->len_set = 0;
     		return 1;
     	case EVP_CTRL_COPY:
+    		{
     			EVP_CIPHER_CTX *out = ptr;
     			EVP_AES_CCM_CTX *cctx_out = out->cipher_data;
     			if (cctx->ccm.key)
+    				{
     				if (cctx->ccm.key != &cctx->ks)
     					return 0;
     				cctx_out->ccm.key = &cctx_out->ks;
+    				}
     			return 1;
+    		}
     	default:
     		return -1;

+    	{
     	int cipher_nid, md_nid;
     	if (cipher)
     		cipher_nid = EVP_CIPHER_type(cipher);
     		cipher_nid = EVP_CIPHER_nid(cipher);
     	else
     		cipher_nid = -1;
     	if (md)

+                    }
             memcpy(cfb_tmp,cfb_iv,8);
             n=0;
             idea_cfb64_encrypt(cfb_buf1,cfb_buf2,(long)17,&eks,
             idea_cfb64_encrypt(cfb_buf1,cfb_buf2,(long)13,&eks,
                     cfb_tmp,&n,IDEA_DECRYPT);
             idea_cfb64_encrypt(&(cfb_buf1[17]),&(cfb_buf2[17]),
                     (long)CFB_TEST_SIZE-17,&dks,
             idea_cfb64_encrypt(&(cfb_buf1[13]),&(cfb_buf2[13]),
                     (long)CFB_TEST_SIZE-13,&eks,
                     cfb_tmp,&n,IDEA_DECRYPT);
             if (memcmp(plain,cfb_buf2,CFB_TEST_SIZE) != 0)
+                    {

     	const unsigned char *p;
     	char tbuf[DECIMAL_SIZE(i)+DECIMAL_SIZE(l)+2];
     	if ((a == NULL) || (a->data == NULL)) {
     		buf[0]='\0';
     		return(0);
+    	}
     	/* Ensure that, at every state, |buf| is NUL-terminated. */
     	if (buf && buf_len > 0)
     		buf[0] = '\0';
     	if ((a == NULL) || (a->data == NULL))
     		return(0);
     	if (!no_name && (nid=OBJ_obj2nid(a)) != NID_undef)
+    		{
-...
     				i=(int)(l/40);
     				l-=(long)(i*40);
+    				}
     			if (buf && (buf_len > 0))
     			if (buf && (buf_len > 1))
+    				{
     				*buf++ = i + '0';
     				*buf = '\0';
     				buf_len--;
+    				}
     			n++;
-...
     			i = strlen(bndec);
     			if (buf)
+    				{
     				if (buf_len > 0)
     				if (buf_len > 1)
+    					{
     					*buf++ = '.';
     					*buf = '\0';
     					buf_len--;
+    					}
     				BUF_strlcpy(buf,bndec,buf_len);
-...
     	OPENSSL_free(buf);
     	return(ok);
+    	}

     #define NUM_LN 913
     #define NUM_OBJ 857
     static const unsigned char lvalues[5980]={
 x00,                                        /* [  0] OBJ_undef */
 x2A,0x86,0x48,0x86,0xF7,0x0D,               /* [  1] OBJ_rsadsi */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,          /* [  7] OBJ_pkcs */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x02,0x02,     /* [ 14] OBJ_md2 */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x02,0x05,     /* [ 22] OBJ_md5 */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x03,0x04,     /* [ 30] OBJ_rc4 */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x01,0x01,/* [ 38] OBJ_rsaEncryption */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x01,0x02,/* [ 47] OBJ_md2WithRSAEncryption */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x01,0x04,/* [ 56] OBJ_md5WithRSAEncryption */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x05,0x01,/* [ 65] OBJ_pbeWithMD2AndDES_CBC */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x05,0x03,/* [ 74] OBJ_pbeWithMD5AndDES_CBC */
 x55,                                        /* [ 83] OBJ_X500 */
 x55,0x04,                                   /* [ 84] OBJ_X509 */
 x55,0x04,0x03,                              /* [ 86] OBJ_commonName */
 x55,0x04,0x06,                              /* [ 89] OBJ_countryName */
 x55,0x04,0x07,                              /* [ 92] OBJ_localityName */
 x55,0x04,0x08,                              /* [ 95] OBJ_stateOrProvinceName */
 x55,0x04,0x0A,                              /* [ 98] OBJ_organizationName */
 x55,0x04,0x0B,                              /* [101] OBJ_organizationalUnitName */
 x55,0x08,0x01,0x01,                         /* [104] OBJ_rsa */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x07,     /* [108] OBJ_pkcs7 */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x07,0x01,/* [116] OBJ_pkcs7_data */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x07,0x02,/* [125] OBJ_pkcs7_signed */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x07,0x03,/* [134] OBJ_pkcs7_enveloped */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x07,0x04,/* [143] OBJ_pkcs7_signedAndEnveloped */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x07,0x05,/* [152] OBJ_pkcs7_digest */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x07,0x06,/* [161] OBJ_pkcs7_encrypted */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x03,     /* [170] OBJ_pkcs3 */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x03,0x01,/* [178] OBJ_dhKeyAgreement */
 x2B,0x0E,0x03,0x02,0x06,                    /* [187] OBJ_des_ecb */
 x2B,0x0E,0x03,0x02,0x09,                    /* [192] OBJ_des_cfb64 */
 x2B,0x0E,0x03,0x02,0x07,                    /* [197] OBJ_des_cbc */
 x2B,0x0E,0x03,0x02,0x11,                    /* [202] OBJ_des_ede_ecb */
 x2B,0x06,0x01,0x04,0x01,0x81,0x3C,0x07,0x01,0x01,0x02,/* [207] OBJ_idea_cbc */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x03,0x02,     /* [218] OBJ_rc2_cbc */
 x2B,0x0E,0x03,0x02,0x12,                    /* [226] OBJ_sha */
 x2B,0x0E,0x03,0x02,0x0F,                    /* [231] OBJ_shaWithRSAEncryption */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x03,0x07,     /* [236] OBJ_des_ede3_cbc */
 x2B,0x0E,0x03,0x02,0x08,                    /* [244] OBJ_des_ofb64 */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x09,     /* [249] OBJ_pkcs9 */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x09,0x01,/* [257] OBJ_pkcs9_emailAddress */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x09,0x02,/* [266] OBJ_pkcs9_unstructuredName */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x09,0x03,/* [275] OBJ_pkcs9_contentType */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x09,0x04,/* [284] OBJ_pkcs9_messageDigest */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x09,0x05,/* [293] OBJ_pkcs9_signingTime */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x09,0x06,/* [302] OBJ_pkcs9_countersignature */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x09,0x07,/* [311] OBJ_pkcs9_challengePassword */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x09,0x08,/* [320] OBJ_pkcs9_unstructuredAddress */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x09,0x09,/* [329] OBJ_pkcs9_extCertAttributes */
 x60,0x86,0x48,0x01,0x86,0xF8,0x42,          /* [338] OBJ_netscape */
 x60,0x86,0x48,0x01,0x86,0xF8,0x42,0x01,     /* [345] OBJ_netscape_cert_extension */
 x60,0x86,0x48,0x01,0x86,0xF8,0x42,0x02,     /* [353] OBJ_netscape_data_type */
 x2B,0x0E,0x03,0x02,0x1A,                    /* [361] OBJ_sha1 */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x01,0x05,/* [366] OBJ_sha1WithRSAEncryption */
 x2B,0x0E,0x03,0x02,0x0D,                    /* [375] OBJ_dsaWithSHA */
 x2B,0x0E,0x03,0x02,0x0C,                    /* [380] OBJ_dsa_2 */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x05,0x0B,/* [385] OBJ_pbeWithSHA1AndRC2_CBC */
 x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x05,0x0C,/* [394] OBJ_id_pbkdf2 */
 x2B,0x0E,0x03,0x02,0x1B,                    /* [403] OBJ_dsaWithSHA1_2 */
 x60,0x86,0x48,0x01,0x86,0xF8,0x42,0x01,0x01,/* [408] OBJ_netscape_cert_type */
 x60,0x86,0x48,0x01,0x86,0xF8,0x42,0x01,0x02,/* [417] OBJ_netscape_base_url */
 x60,0x86,0x48,0x01,0x86,0xF8,0x42,0x01,0x03,/* [426] OBJ_netscape_revocation_url */
 x60,0x86,0x48,0x01,0x86,0xF8,0x42,0x01,0x04,/* [435] OBJ_netscape_ca_revocation_url */
 x60,0x86,0x48,0x01,0x86,0xF8,0x42,0x01,0x07,/* [444] OBJ_netscape_renewal_url */
 x60,0x86,0x48,0x01,0x86,0xF8,0x42,0x01,0x08,/* [453] OBJ_netscape_ca_policy_url */
 x60,0x86,0x48,0x01,0x86,0xF8,0x42,0x01,0x0C,/* [462] OBJ_netscape_ssl_server_name */
 x60,0x86,0x48,0x01,0x86,0xF8,0x42,0x01,0x0D,/* [471] OBJ_netscape_comment */
 x60,0x86,0x48,0x01,0x86,0xF8,0x42,0x02,0x05,/* [480] OBJ_netscape_cert_sequence */
 x55,0x1D,                                   /* [489] OBJ_id_ce */
 x55,0x1D,0x0E,                              /* [491] OBJ_subject_key_identifier */

CSE2410 Fall 2014 Bounce

Revision aa3b4b4d