grpc-flamingo 1.11.0 → 1.15.0

data/third_party/boringssl/include/openssl/ssl3.h

@@ -300,7 +300,6 @@ OPENSSL_COMPILE_ASSERT(
 #define SSL3_MT_SERVER_HELLO 2
 #define SSL3_MT_NEW_SESSION_TICKET 4
 #define SSL3_MT_END_OF_EARLY_DATA 5
-#define SSL3_MT_HELLO_RETRY_REQUEST 6
 #define SSL3_MT_ENCRYPTED_EXTENSIONS 8
 #define SSL3_MT_CERTIFICATE 11
 #define SSL3_MT_SERVER_KEY_EXCHANGE 12

data/third_party/boringssl/include/openssl/stack.h

@@ -344,7 +344,7 @@ struct StackTraits {};
       sk_##name##_deep_copy(const STACK_OF(name) *sk,                          \
                             ptrtype(*copy_func)(ptrtype),                      \
                             void (*free_func)(ptrtype)) {                      \
-    return (STACK_OF(name) *)sk_deep_copy((_STACK *)sk,                        \
+    return (STACK_OF(name) *)sk_deep_copy((const _STACK *)sk,                  \
                                           (void *(*)(void *))copy_func,        \
                                           (void (*)(void *))free_func);        \
   }

data/third_party/boringssl/include/openssl/tls1.h

@@ -202,19 +202,24 @@ extern "C" {
 // ExtensionType value from RFC7627
 #define TLSEXT_TYPE_extended_master_secret 23
 
+// ExtensionType value from draft-ietf-tokbind-negotiation-10
+#define TLSEXT_TYPE_token_binding 24
+
+// ExtensionType value from draft-ietf-quic-tls
+#define TLSEXT_TYPE_quic_transport_parameters 26
+
 // ExtensionType value from RFC4507
 #define TLSEXT_TYPE_session_ticket 35
 
 // ExtensionType values from draft-ietf-tls-tls13-18
 #define TLSEXT_TYPE_supported_groups 10
-#define TLSEXT_TYPE_key_share 40
 #define TLSEXT_TYPE_pre_shared_key 41
 #define TLSEXT_TYPE_early_data 42
 #define TLSEXT_TYPE_supported_versions 43
 #define TLSEXT_TYPE_cookie 44
 #define TLSEXT_TYPE_psk_key_exchange_modes 45
-#define TLSEXT_TYPE_ticket_early_data_info 46
 #define TLSEXT_TYPE_certificate_authorities 47
+#define TLSEXT_TYPE_key_share 51
 
 // ExtensionType value from RFC5746
 #define TLSEXT_TYPE_renegotiate 0xff01
@@ -228,6 +233,9 @@ extern "C" {
 // This is not an IANA defined extension number
 #define TLSEXT_TYPE_channel_id 30032
 
+// This is not an IANA defined extension number
+#define TLSEXT_TYPE_dummy_pq_padding 54537
+
 // status request value from RFC 3546
 #define TLSEXT_STATUSTYPE_ocsp 1
 

data/third_party/boringssl/include/openssl/x509.h

@@ -690,6 +690,9 @@ OPENSSL_EXPORT X509_NAME *X509_NAME_dup(X509_NAME *xn);
 OPENSSL_EXPORT X509_NAME_ENTRY *X509_NAME_ENTRY_dup(X509_NAME_ENTRY *ne);
 OPENSSL_EXPORT int X509_NAME_ENTRY_set(const X509_NAME_ENTRY *ne);
 
+OPENSSL_EXPORT int X509_NAME_get0_der(X509_NAME *nm, const unsigned char **pder,
+                                      size_t *pderlen);
+
 OPENSSL_EXPORT int		X509_cmp_time(const ASN1_TIME *s, time_t *t);
 OPENSSL_EXPORT int		X509_cmp_current_time(const ASN1_TIME *s);
 OPENSSL_EXPORT ASN1_TIME *	X509_time_adj(ASN1_TIME *s, long adj, time_t *t);
@@ -1107,6 +1110,7 @@ extern "C++" {
 namespace bssl {
 
 BORINGSSL_MAKE_DELETER(NETSCAPE_SPKI, NETSCAPE_SPKI_free)
+BORINGSSL_MAKE_DELETER(RSA_PSS_PARAMS, RSA_PSS_PARAMS_free)
 BORINGSSL_MAKE_DELETER(X509, X509_free)
 BORINGSSL_MAKE_DELETER(X509_ALGOR, X509_ALGOR_free)
 BORINGSSL_MAKE_DELETER(X509_CRL, X509_CRL_free)

data/third_party/boringssl/include/openssl/x509v3.h

@@ -748,6 +748,7 @@ extern "C++" {
 
 namespace bssl {
 
+BORINGSSL_MAKE_DELETER(AUTHORITY_INFO_ACCESS, AUTHORITY_INFO_ACCESS_free)
 BORINGSSL_MAKE_DELETER(AUTHORITY_KEYID, AUTHORITY_KEYID_free)
 BORINGSSL_MAKE_DELETER(BASIC_CONSTRAINTS, BASIC_CONSTRAINTS_free)
 BORINGSSL_MAKE_DELETER(DIST_POINT, DIST_POINT_free)

data/third_party/boringssl/ssl/d1_both.cc

@@ -1,6 +1,6 @@
 /*
  * DTLS implementation written by Nagendra Modadugu
- * (nagendra@cs.stanford.edu) for the OpenSSL project 2005. 
+ * (nagendra@cs.stanford.edu) for the OpenSSL project 2005.
  */
 /* ====================================================================
  * Copyright (c) 1998-2005 The OpenSSL Project.  All rights reserved.
@@ -536,6 +536,20 @@ bool dtls1_finish_message(SSL *ssl, CBB *cbb, Array<uint8_t> *out_msg) {
   return true;
 }
 
+// ssl_size_t_greater_than_32_bits returns whether |v| exceeds the bounds of a
+// 32-bit value. The obvious thing doesn't work because, in some 32-bit build
+// configurations, the compiler warns that the test is always false and breaks
+// the build.
+static bool ssl_size_t_greater_than_32_bits(size_t v) {
+#if defined(OPENSSL_64_BIT)
+  return v > 0xffffffff;
+#elif defined(OPENSSL_32_BIT)
+  return false;
+#else
+#error "Building for neither 32- nor 64-bits."
+#endif
+}
+
 // add_outgoing adds a new handshake message or ChangeCipherSpec to the current
 // outgoing flight. It returns true on success and false on error.
 static bool add_outgoing(SSL *ssl, bool is_ccs, Array<uint8_t> data) {
@@ -550,7 +564,7 @@ static bool add_outgoing(SSL *ssl, bool is_ccs, Array<uint8_t> data) {
                     (1 << 8 * sizeof(ssl->d1->outgoing_messages_len)),
                 "outgoing_messages_len is too small");
   if (ssl->d1->outgoing_messages_len >= SSL_MAX_HANDSHAKE_FLIGHT ||
-      data.size() > 0xffffffff) {
+      ssl_size_t_greater_than_32_bits(data.size())) {
     assert(false);
     OPENSSL_PUT_ERROR(SSL, ERR_R_INTERNAL_ERROR);
     return false;

data/third_party/boringssl/ssl/dtls_method.cc

@@ -1,6 +1,6 @@
 /*
  * DTLS implementation written by Nagendra Modadugu
- * (nagendra@cs.stanford.edu) for the OpenSSL project 2005. 
+ * (nagendra@cs.stanford.edu) for the OpenSSL project 2005.
  */
 /* ====================================================================
  * Copyright (c) 1999-2005 The OpenSSL Project.  All rights reserved.

data/third_party/boringssl/ssl/handoff.cc

@@ -0,0 +1,285 @@
+/* Copyright (c) 2018, Google Inc.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
+
+#include <openssl/ssl.h>
+
+#include <openssl/bytestring.h>
+
+#include "internal.h"
+
+
+namespace bssl {
+
+constexpr int kHandoffVersion = 0;
+constexpr int kHandbackVersion = 0;
+
+bool SSL_serialize_handoff(const SSL *ssl, CBB *out) {
+  const SSL3_STATE *const s3 = ssl->s3;
+  if (!ssl->server ||
+      s3->hs == nullptr ||
+      s3->rwstate != SSL_HANDOFF) {
+    return false;
+  }
+
+  CBB seq;
+  Span<const uint8_t> transcript = s3->hs->transcript.buffer();
+  if (!CBB_add_asn1(out, &seq, CBS_ASN1_SEQUENCE) ||
+      !CBB_add_asn1_uint64(&seq, kHandoffVersion) ||
+      !CBB_add_asn1_octet_string(&seq, transcript.data(), transcript.size()) ||
+      !CBB_add_asn1_octet_string(&seq,
+                                 reinterpret_cast<uint8_t *>(s3->hs_buf->data),
+                                 s3->hs_buf->length) ||
+      !CBB_flush(out)) {
+    return false;
+  }
+
+  return true;
+}
+
+bool SSL_decline_handoff(SSL *ssl) {
+  const SSL3_STATE *const s3 = ssl->s3;
+  if (!ssl->server ||
+      s3->hs == nullptr ||
+      s3->rwstate != SSL_HANDOFF) {
+    return false;
+  }
+
+  ssl->handoff = false;
+  return true;
+}
+
+bool SSL_apply_handoff(SSL *ssl, Span<const uint8_t> handoff) {
+  if (ssl->method->is_dtls) {
+    return false;
+  }
+
+  CBS seq, handoff_cbs(handoff);
+  uint64_t handoff_version;
+  if (!CBS_get_asn1(&handoff_cbs, &seq, CBS_ASN1_SEQUENCE) ||
+      !CBS_get_asn1_uint64(&seq, &handoff_version) ||
+      handoff_version != kHandoffVersion) {
+    return false;
+  }
+
+  CBS transcript, hs_buf;
+  if (!CBS_get_asn1(&seq, &transcript, CBS_ASN1_OCTETSTRING) ||
+      !CBS_get_asn1(&seq, &hs_buf, CBS_ASN1_OCTETSTRING)) {
+    return false;
+  }
+
+  SSL_set_accept_state(ssl);
+
+  SSL3_STATE *const s3 = ssl->s3;
+  s3->v2_hello_done = true;
+  s3->has_message = true;
+
+  s3->hs_buf.reset(BUF_MEM_new());
+  if (!s3->hs_buf ||
+      !BUF_MEM_append(s3->hs_buf.get(), CBS_data(&hs_buf), CBS_len(&hs_buf))) {
+    return false;
+  }
+
+  if (CBS_len(&transcript) != 0) {
+    s3->hs->transcript.Update(transcript);
+    s3->is_v2_hello = true;
+    ssl_do_msg_callback(ssl, 0 /* read */, 0 /* V2ClientHello */, transcript);
+  }
+
+  return true;
+}
+
+bool SSL_serialize_handback(const SSL *ssl, CBB *out) {
+  if (!ssl->server ||
+      !ssl->s3->initial_handshake_complete ||
+      ssl->method->is_dtls ||
+      ssl->version < TLS1_VERSION) {
+    return false;
+  }
+
+  const SSL3_STATE *const s3 = ssl->s3;
+  size_t hostname_len = 0;
+  if (s3->hostname) {
+    hostname_len = strlen(s3->hostname.get());
+  }
+
+  size_t iv_len = 0;
+  const uint8_t *read_iv = nullptr, *write_iv = nullptr;
+  if (ssl->version == TLS1_VERSION &&
+      SSL_CIPHER_is_block_cipher(s3->aead_read_ctx->cipher()) &&
+      (!s3->aead_read_ctx->GetIV(&read_iv, &iv_len) ||
+       !s3->aead_write_ctx->GetIV(&write_iv, &iv_len))) {
+    return false;
+  }
+
+  CBB seq;
+  if (!CBB_add_asn1(out, &seq, CBS_ASN1_SEQUENCE) ||
+      !CBB_add_asn1_uint64(&seq, kHandbackVersion) ||
+      !CBB_add_asn1_uint64(&seq, ssl->version) ||
+      !CBB_add_asn1_uint64(&seq, ssl->conf_max_version) ||
+      !CBB_add_asn1_uint64(&seq, ssl->conf_min_version) ||
+      !CBB_add_asn1_uint64(&seq, ssl->max_send_fragment) ||
+      !CBB_add_asn1_octet_string(&seq, s3->read_sequence,
+                                 sizeof(s3->read_sequence)) ||
+      !CBB_add_asn1_octet_string(&seq, s3->write_sequence,
+                                 sizeof(s3->write_sequence)) ||
+      !CBB_add_asn1_octet_string(&seq, s3->server_random,
+                                 sizeof(s3->server_random)) ||
+      !CBB_add_asn1_octet_string(&seq, s3->client_random,
+                                 sizeof(s3->client_random)) ||
+      !CBB_add_asn1_octet_string(&seq, read_iv, iv_len) ||
+      !CBB_add_asn1_octet_string(&seq, write_iv, iv_len) ||
+      !CBB_add_asn1_bool(&seq, s3->session_reused) ||
+      !CBB_add_asn1_bool(&seq, s3->send_connection_binding) ||
+      !CBB_add_asn1_bool(&seq, s3->tlsext_channel_id_valid) ||
+      !ssl_session_serialize(s3->established_session.get(), &seq) ||
+      !CBB_add_asn1_octet_string(&seq, s3->next_proto_negotiated.data(),
+                                 s3->next_proto_negotiated.size()) ||
+      !CBB_add_asn1_octet_string(&seq, s3->alpn_selected.data(),
+                                 s3->alpn_selected.size()) ||
+      !CBB_add_asn1_octet_string(
+          &seq, reinterpret_cast<uint8_t *>(s3->hostname.get()),
+          hostname_len) ||
+      !CBB_add_asn1_octet_string(&seq, s3->tlsext_channel_id,
+                                 sizeof(s3->tlsext_channel_id)) ||
+      !CBB_add_asn1_uint64(&seq, ssl->options) ||
+      !CBB_add_asn1_uint64(&seq, ssl->mode) ||
+      !CBB_add_asn1_uint64(&seq, ssl->max_cert_list) ||
+      !CBB_add_asn1_bool(&seq, ssl->quiet_shutdown) ||
+      !CBB_add_asn1_bool(&seq, ssl->tlsext_channel_id_enabled) ||
+      !CBB_add_asn1_bool(&seq, ssl->retain_only_sha256_of_client_certs) ||
+      !CBB_flush(out)) {
+    return false;
+  }
+
+  return true;
+}
+
+bool SSL_apply_handback(SSL *ssl, Span<const uint8_t> handback) {
+  if (ssl->do_handshake != nullptr ||
+      ssl->method->is_dtls) {
+    return false;
+  }
+
+  SSL3_STATE *const s3 = ssl->s3;
+  uint64_t handback_version, version, conf_max_version, conf_min_version,
+      max_send_fragment, options, mode, max_cert_list;
+  CBS seq, read_seq, write_seq, server_rand, client_rand, read_iv, write_iv,
+      next_proto, alpn, hostname, channel_id;
+  int session_reused, send_connection_binding, channel_id_valid,
+      quiet_shutdown, channel_id_enabled, retain_only_sha256;
+
+  CBS handback_cbs(handback);
+  if (!CBS_get_asn1(&handback_cbs, &seq, CBS_ASN1_SEQUENCE) ||
+      !CBS_get_asn1_uint64(&seq, &handback_version) ||
+      handback_version != kHandbackVersion) {
+    return false;
+  }
+
+  if (!CBS_get_asn1_uint64(&seq, &version) ||
+      !CBS_get_asn1_uint64(&seq, &conf_max_version) ||
+      !CBS_get_asn1_uint64(&seq, &conf_min_version) ||
+      !CBS_get_asn1_uint64(&seq, &max_send_fragment) ||
+      !CBS_get_asn1(&seq, &read_seq, CBS_ASN1_OCTETSTRING) ||
+      CBS_len(&read_seq) != sizeof(s3->read_sequence) ||
+      !CBS_get_asn1(&seq, &write_seq, CBS_ASN1_OCTETSTRING) ||
+      CBS_len(&write_seq) != sizeof(s3->write_sequence) ||
+      !CBS_get_asn1(&seq, &server_rand, CBS_ASN1_OCTETSTRING) ||
+      CBS_len(&server_rand) != sizeof(s3->server_random) ||
+      !CBS_copy_bytes(&server_rand, s3->server_random,
+                      sizeof(s3->server_random)) ||
+      !CBS_get_asn1(&seq, &client_rand, CBS_ASN1_OCTETSTRING) ||
+      CBS_len(&client_rand) != sizeof(s3->client_random) ||
+      !CBS_copy_bytes(&client_rand, s3->client_random,
+                      sizeof(s3->client_random)) ||
+      !CBS_get_asn1(&seq, &read_iv, CBS_ASN1_OCTETSTRING) ||
+      !CBS_get_asn1(&seq, &write_iv, CBS_ASN1_OCTETSTRING) ||
+      !CBS_get_asn1_bool(&seq, &session_reused) ||
+      !CBS_get_asn1_bool(&seq, &send_connection_binding) ||
+      !CBS_get_asn1_bool(&seq, &channel_id_valid)) {
+    return false;
+  }
+
+  s3->established_session =
+      SSL_SESSION_parse(&seq, ssl->ctx->x509_method, ssl->ctx->pool);
+
+  if (!s3->established_session ||
+      !CBS_get_asn1(&seq, &next_proto, CBS_ASN1_OCTETSTRING) ||
+      !CBS_get_asn1(&seq, &alpn, CBS_ASN1_OCTETSTRING) ||
+      !CBS_get_asn1(&seq, &hostname, CBS_ASN1_OCTETSTRING) ||
+      !CBS_get_asn1(&seq, &channel_id, CBS_ASN1_OCTETSTRING) ||
+      CBS_len(&channel_id) != sizeof(s3->tlsext_channel_id) ||
+      !CBS_copy_bytes(&channel_id, s3->tlsext_channel_id,
+                      sizeof(s3->tlsext_channel_id)) ||
+      !CBS_get_asn1_uint64(&seq, &options) ||
+      !CBS_get_asn1_uint64(&seq, &mode) ||
+      !CBS_get_asn1_uint64(&seq, &max_cert_list) ||
+      !CBS_get_asn1_bool(&seq, &quiet_shutdown) ||
+      !CBS_get_asn1_bool(&seq, &channel_id_enabled) ||
+      !CBS_get_asn1_bool(&seq, &retain_only_sha256)) {
+    return false;
+  }
+
+  ssl->version = version;
+  ssl->conf_max_version = conf_max_version;
+  ssl->conf_min_version = conf_min_version;
+  ssl->max_send_fragment = max_send_fragment;
+  ssl->do_handshake = ssl_server_handshake;
+  ssl->server = true;
+  ssl->options = options;
+  ssl->mode = mode;
+  ssl->max_cert_list = max_cert_list;
+
+  s3->hs.reset();
+  s3->have_version = true;
+  s3->initial_handshake_complete = true;
+  s3->session_reused = session_reused;
+  s3->send_connection_binding = send_connection_binding;
+  s3->tlsext_channel_id_valid = channel_id_valid;
+  s3->next_proto_negotiated.CopyFrom(next_proto);
+  s3->alpn_selected.CopyFrom(alpn);
+
+  const size_t hostname_len = CBS_len(&hostname);
+  if (hostname_len == 0) {
+    s3->hostname.reset();
+  } else {
+    char *hostname_str = nullptr;
+    if (!CBS_strdup(&hostname, &hostname_str)) {
+      return false;
+    }
+    s3->hostname.reset(hostname_str);
+  }
+
+  ssl->quiet_shutdown = quiet_shutdown;
+  ssl->tlsext_channel_id_enabled = channel_id_enabled;
+  ssl->retain_only_sha256_of_client_certs = retain_only_sha256;
+
+  Array<uint8_t> key_block;
+  if (!tls1_configure_aead(ssl, evp_aead_open, &key_block,
+                           s3->established_session->cipher, read_iv) ||
+      !tls1_configure_aead(ssl, evp_aead_seal, &key_block,
+                           s3->established_session->cipher, write_iv)) {
+    return false;
+  }
+
+  if (!CBS_copy_bytes(&read_seq, s3->read_sequence,
+                      sizeof(s3->read_sequence)) ||
+      !CBS_copy_bytes(&write_seq, s3->write_sequence,
+                      sizeof(s3->write_sequence))) {
+    return false;
+  }
+
+  return true;
+}
+
+}  // namespace bssl

data/third_party/boringssl/ssl/handshake.cc

@@ -116,6 +116,8 @@
 
 #include <utility>
 
+#include <openssl/rand.h>
+
 #include "../crypto/internal.h"
 #include "internal.h"
 
@@ -143,7 +145,8 @@ SSL_HANDSHAKE::SSL_HANDSHAKE(SSL *ssl_arg)
       next_proto_neg_seen(false),
       ticket_expected(false),
       extended_master_secret(false),
-      pending_private_key_op(false) {
+      pending_private_key_op(false),
+      grease_seeded(false) {
 }
 
 SSL_HANDSHAKE::~SSL_HANDSHAKE() {
@@ -331,6 +334,11 @@ enum ssl_verify_result_t ssl_verify_peer_cert(SSL_HANDSHAKE *hs) {
         hs->new_session->verify_result = X509_V_OK;
         break;
       case ssl_verify_invalid:
+        // If |SSL_VERIFY_NONE|, the error is non-fatal, but we keep the result.
+        if (ssl->verify_mode == SSL_VERIFY_NONE) {
+          ERR_clear_error();
+          ret = ssl_verify_ok;
+        }
         hs->new_session->verify_result = X509_V_ERR_APPLICATION_VERIFICATION;
         break;
       case ssl_verify_retry:
@@ -351,18 +359,19 @@ enum ssl_verify_result_t ssl_verify_peer_cert(SSL_HANDSHAKE *hs) {
   return ret;
 }
 
-uint16_t ssl_get_grease_value(const SSL *ssl, enum ssl_grease_index_t index) {
-  // Use the client_random or server_random for entropy. This both avoids
-  // calling |RAND_bytes| on a single byte repeatedly and ensures the values are
-  // deterministic. This allows the same ClientHello be sent twice for a
-  // HelloRetryRequest or the same group be advertised in both supported_groups
-  // and key_shares.
-  uint16_t ret = ssl->server ? ssl->s3->server_random[index]
-                             : ssl->s3->client_random[index];
-  // The first four bytes of server_random are a timestamp prior to TLS 1.3, but
-  // servers have no fields to GREASE until TLS 1.3.
-  assert(!ssl->server || ssl_protocol_version(ssl) >= TLS1_3_VERSION);
+uint16_t ssl_get_grease_value(SSL_HANDSHAKE *hs,
+                              enum ssl_grease_index_t index) {
+  // Draw entropy for all GREASE values at once. This avoids calling
+  // |RAND_bytes| repeatedly and makes the values consistent within a
+  // connection. The latter is so the second ClientHello matches after
+  // HelloRetryRequest and so supported_groups and key_shares are consistent.
+  if (!hs->grease_seeded) {
+    RAND_bytes(hs->grease_seed, sizeof(hs->grease_seed));
+    hs->grease_seeded = true;
+  }
+
   // This generates a random value of the form 0xωaωa, for all 0 ≤ ω < 16.
+  uint16_t ret = hs->grease_seed[index];
   ret = (ret & 0xf0) | 0x0a;
   ret |= ret << 8;
   return ret;
@@ -551,6 +560,11 @@ int ssl_run_handshake(SSL_HANDSHAKE *hs, bool *out_early_return) {
         hs->wait = ssl_hs_ok;
         return -1;
 
+      case ssl_hs_handoff:
+        ssl->s3->rwstate = SSL_HANDOFF;
+        hs->wait = ssl_hs_ok;
+        return -1;
+
       case ssl_hs_x509_lookup:
         ssl->s3->rwstate = SSL_X509_LOOKUP;
         hs->wait = ssl_hs_ok;