xref: /third_party/openssl/test/sslapitest.c

400      * Now we want to test that our output data was vaguely sensible. We
402      * data we expect. For both client and server, we expect to see one master
477      * Now we want to test that our output data was vaguely sensible. For this
493     /* Terminate old session and resume with early data. */
510             /* Here writing 0 length early data is enough. */
1512  * Test we can successfully send the maximum amount of application data. We
1738      * Since we called SSL_peek(), we know the data in the record
1743     zbuf = &rr->data[rr->off];
3382  * Helper method to setup objects for early data test. Caller frees objects on
3418      * some SNI data in the initial ClientHello. This will be ignored (because
3482     unsigned char buf[20], data[1024];
3491     /* Write and read some early data */
3504      * Server should be able to write data, and client should be able to
3514     /* Even after reading normal data, client should be able write early data */
3520     /* Server should still be able read early data after writing data */
3527     /* Write more data from server and read it from client */
3536      * If client writes normal data it should mean writing early data is no
3547      * normal (fully protected) data. We are going to cause a delay between the
3548      * arrival of EndOfEarlyData and ClientFinished. We read out all the data
3552     if (!TEST_true(BIO_read_ex(rbio, data, sizeof(data), &rawread))
3553             || !TEST_size_t_lt(rawread, sizeof(data))
3558     eoedlen = SSL3_RT_HEADER_LENGTH + (data[3] << 8 | data[4]);
3559     if (!TEST_true(BIO_write_ex(rbio, data, eoedlen, &rawwritten))
3563     /* Server should be told that there is no more early data */
3572      * data.
3579     /* Push the ClientFinished and the normal data back into the server rbio */
3580     if (!TEST_true(BIO_write_ex(rbio, data + eoedlen, rawread - eoedlen,
3585     /* Server should be able to read normal data */
3590     /* Client and server should not be able to write/read early data now */
3601     /* Client should be able to read the data sent by the server */
3609      * data.
3616     /* Server should be able to write normal data */
3638     /* Write and read some early data */
3652     /* Client and server should not be able to write/read early data now */
3663     /* Client and server should be able to write/read normal data */
3701  * usecb == 0: Don't use a custom early data callback
3702  * usecb == 1: Use a custom early data callback and reject the early data
3703  * usecb == 2: Use a custom early data callback and accept the early data
3750      * The server is configured to accept early data. Create a connection to
3768     /* Write and read some early data */
3780                     * early data
3786         /* In this case the callback decides to accept the early data */
3793                     * end of early data and complete its half of the handshake
3847  * Helper function to test that a server attempting to read early data can
3848  * handle a connection from a client where the early data should be skipped.
3916     /* Write some early data */
3922     /* Server should reject the early data */
3996      * Should be able to send normal data despite rejection of early data. The
4008      * Failure to decrypt early data records should not leave spurious errors
4029  * Test that a server attempting to read early data can handle a connection
4030  * from a client where the early data is not acceptable.
4040  * Test that a server attempting to read early data can handle a connection
4051  * Test that a server attempting to read early data can handle a connection
4063  * Test that a server attempting to read early data will abort if it tries to
4074  * Test that a server attempting to read early data can handle a connection
4091     /* Write some data - should block due to handshake with server */
4096     /* Server should detect that early data has not been sent */
4416     /* Send some normal data from client to server */
4443  * Test that a server that doesn't try to read early data can handle a
4460     /* Write some early data */
4466      * Server should skip over early data and then block waiting for client to
4478     /* Send some normal data from client to server */
4504  * Test that a server attempting to read early data can handle a connection
4520     /* Write some data - should block due to handshake with server */
4529      * finish and detect that early data has not been sent
5711     unsigned char *data;
5719             || (data = OPENSSL_malloc(sizeof(*data))) == NULL)
5722     *data = 1;
5723     *out = data;
5757     unsigned char *data;
5765             || (data = OPENSSL_malloc(sizeof(*data))) == NULL)
5768     *data = 1;
5769     *out = data;
5770     *outlen = sizeof(*data);
6374     /* Here writing 0 length early data is enough. */
6461         /* Check that sending and receiving app data is ok */
6486  * write data is pending in peer.
6529     /* Write data that we know will fail with SSL_ERROR_WANT_WRITE */
6538     /* Now read some data - we will read the key update */
6551     /* Write more data to ensure we send the KeyUpdate message back */
6571  * peer read data is pending after peer accepted keyupdate(the msg header
6608      * write data in local will fail with SSL_ERROR_WANT_WRITE,because
6609      * lwbuf app data msg size + key updata msg size > 512(the size of
6625     /* Now write some data in peer - we will write the key update */
6630      * write data in local previously that we will complete
6631      * read data in peer previously that we will complete
6655  * local write data is pending.
6694     /* write data in local will fail with SSL_ERROR_WANT_WRITE */
6709     /* write data in local previously that we will complete */
6713     /* SSL_key_update will succeed because there is no pending write data */
6720      * read data in peer - we will read the keyupdate msg
6726     /* Write more peer more data to ensure we send the keyupdate message back */
6746  * local read data is pending(the msg header had been read 5 bytes).
6780     /* write app data in peer will fail with SSL_ERROR_WANT_WRITE */
6796      * write data in peer previously that we will complete
6797      * read data in local previously that we will complete
6804      * write data in local
6805      * read data in peer - we will read the key update
6811   /* Write more peer data to ensure we send the keyupdate message back */
6886     unsigned char *data;
6890     if (!TEST_uint_gt( len = BIO_get_mem_data( bio, (char **) &data ), 0 ) )
6898             || !TEST_true( PACKET_buf_init( &pkt, data, len ) )
7105      * The only way to create an empty TXT_DB is to provide a BIO with no data
7466         /* Write and read some early data and then complete the connection */
8035      * actually send any ticket data). This does not happen in TLSv1.3 because
8036      * it is not valid to send empty ticket data in TLSv1.3.
8239             /* Should still be able to read data from server */
8288          * back, but instead there is application data first. The shutdown
8769     /* Set up a buffer with some data that will be sent to the client */
10235  * Test 2: Client has pipelining enabled, server does not: not enough data to
10237  * Test 3: Client has pipelining enabled, server does not: not enough data to
10239  * Test 4: Client has pipelining enabled, server does not: more data than all
10335     /* Write some data from peera to peerb */
10347      * read for left over data that couldn't fit in the previous pipelines
10364      * Write some data from peerb to peera. We do this in up to |numpipes + 1|
10378      * The data was written in |numpipes|, |numpipes - 1| or |numpipes + 1|

Indexes created Thu Nov 07 10:32:03 CST 2024