From 14ddb694bbb3c9305a88c2f04345fb9499f8cd09 Mon Sep 17 00:00:00 2001 From: beck <> Date: Sat, 8 Jul 2023 16:40:14 +0000 Subject: Hide all public symbols in libssl With the guentherizer 9000 ok tb@ --- src/lib/libssl/ssl_lib.c | 197 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 196 insertions(+), 1 deletion(-) (limited to 'src/lib/libssl/ssl_lib.c') diff --git a/src/lib/libssl/ssl_lib.c b/src/lib/libssl/ssl_lib.c index f6c9406139..b1169b0242 100644 --- a/src/lib/libssl/ssl_lib.c +++ b/src/lib/libssl/ssl_lib.c @@ -1,4 +1,4 @@ -/* $OpenBSD: ssl_lib.c,v 1.310 2023/05/26 13:44:05 tb Exp $ */ +/* $OpenBSD: ssl_lib.c,v 1.311 2023/07/08 16:40:13 beck Exp $ */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * @@ -218,6 +218,7 @@ SSL_clear(SSL *s) return (1); } +LSSL_ALIAS(SSL_clear); /* Used to change an SSL_CTXs default SSL method type */ int @@ -236,6 +237,7 @@ SSL_CTX_set_ssl_version(SSL_CTX *ctx, const SSL_METHOD *meth) } return (1); } +LSSL_ALIAS(SSL_CTX_set_ssl_version); SSL * SSL_new(SSL_CTX *ctx) @@ -360,6 +362,7 @@ SSL_new(SSL_CTX *ctx) SSLerrorx(ERR_R_MALLOC_FAILURE); return (NULL); } +LSSL_ALIAS(SSL_new); int SSL_CTX_set_session_id_context(SSL_CTX *ctx, const unsigned char *sid_ctx, @@ -374,6 +377,7 @@ SSL_CTX_set_session_id_context(SSL_CTX *ctx, const unsigned char *sid_ctx, return (1); } +LSSL_ALIAS(SSL_CTX_set_session_id_context); int SSL_set_session_id_context(SSL *ssl, const unsigned char *sid_ctx, @@ -388,6 +392,7 @@ SSL_set_session_id_context(SSL *ssl, const unsigned char *sid_ctx, return (1); } +LSSL_ALIAS(SSL_set_session_id_context); int SSL_CTX_set_generate_session_id(SSL_CTX *ctx, GEN_SESSION_CB cb) @@ -397,6 +402,7 @@ SSL_CTX_set_generate_session_id(SSL_CTX *ctx, GEN_SESSION_CB cb) CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX); return (1); } +LSSL_ALIAS(SSL_CTX_set_generate_session_id); int SSL_set_generate_session_id(SSL *ssl, GEN_SESSION_CB cb) @@ -406,6 +412,7 @@ SSL_set_generate_session_id(SSL *ssl, GEN_SESSION_CB cb) CRYPTO_w_unlock(CRYPTO_LOCK_SSL); return (1); } +LSSL_ALIAS(SSL_set_generate_session_id); int SSL_has_matching_session_id(const SSL *ssl, const unsigned char *id, @@ -432,30 +439,35 @@ SSL_has_matching_session_id(const SSL *ssl, const unsigned char *id, CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX); return (p != NULL); } +LSSL_ALIAS(SSL_has_matching_session_id); int SSL_CTX_set_purpose(SSL_CTX *s, int purpose) { return (X509_VERIFY_PARAM_set_purpose(s->param, purpose)); } +LSSL_ALIAS(SSL_CTX_set_purpose); int SSL_set_purpose(SSL *s, int purpose) { return (X509_VERIFY_PARAM_set_purpose(s->param, purpose)); } +LSSL_ALIAS(SSL_set_purpose); int SSL_CTX_set_trust(SSL_CTX *s, int trust) { return (X509_VERIFY_PARAM_set_trust(s->param, trust)); } +LSSL_ALIAS(SSL_CTX_set_trust); int SSL_set_trust(SSL *s, int trust) { return (X509_VERIFY_PARAM_set_trust(s->param, trust)); } +LSSL_ALIAS(SSL_set_trust); int SSL_set1_host(SSL *s, const char *hostname) @@ -470,42 +482,49 @@ SSL_set1_host(SSL *s, const char *hostname) else return X509_VERIFY_PARAM_set1_host(s->param, hostname, 0); } +LSSL_ALIAS(SSL_set1_host); void SSL_set_hostflags(SSL *s, unsigned int flags) { X509_VERIFY_PARAM_set_hostflags(s->param, flags); } +LSSL_ALIAS(SSL_set_hostflags); const char * SSL_get0_peername(SSL *s) { return X509_VERIFY_PARAM_get0_peername(s->param); } +LSSL_ALIAS(SSL_get0_peername); X509_VERIFY_PARAM * SSL_CTX_get0_param(SSL_CTX *ctx) { return (ctx->param); } +LSSL_ALIAS(SSL_CTX_get0_param); int SSL_CTX_set1_param(SSL_CTX *ctx, X509_VERIFY_PARAM *vpm) { return (X509_VERIFY_PARAM_set1(ctx->param, vpm)); } +LSSL_ALIAS(SSL_CTX_set1_param); X509_VERIFY_PARAM * SSL_get0_param(SSL *ssl) { return (ssl->param); } +LSSL_ALIAS(SSL_get0_param); int SSL_set1_param(SSL *ssl, X509_VERIFY_PARAM *vpm) { return (X509_VERIFY_PARAM_set1(ssl->param, vpm)); } +LSSL_ALIAS(SSL_set1_param); void SSL_free(SSL *s) @@ -585,6 +604,7 @@ SSL_free(SSL *s) free(s); } +LSSL_ALIAS(SSL_free); int SSL_up_ref(SSL *s) @@ -592,6 +612,7 @@ SSL_up_ref(SSL *s) int refs = CRYPTO_add(&s->references, 1, CRYPTO_LOCK_SSL); return (refs > 1) ? 1 : 0; } +LSSL_ALIAS(SSL_up_ref); void SSL_set_bio(SSL *s, BIO *rbio, BIO *wbio) @@ -611,12 +632,14 @@ SSL_set_bio(SSL *s, BIO *rbio, BIO *wbio) s->rbio = rbio; s->wbio = wbio; } +LSSL_ALIAS(SSL_set_bio); BIO * SSL_get_rbio(const SSL *s) { return (s->rbio); } +LSSL_ALIAS(SSL_get_rbio); void SSL_set0_rbio(SSL *s, BIO *rbio) @@ -624,18 +647,21 @@ SSL_set0_rbio(SSL *s, BIO *rbio) BIO_free_all(s->rbio); s->rbio = rbio; } +LSSL_ALIAS(SSL_set0_rbio); BIO * SSL_get_wbio(const SSL *s) { return (s->wbio); } +LSSL_ALIAS(SSL_get_wbio); int SSL_get_fd(const SSL *s) { return (SSL_get_rfd(s)); } +LSSL_ALIAS(SSL_get_fd); int SSL_get_rfd(const SSL *s) @@ -649,6 +675,7 @@ SSL_get_rfd(const SSL *s) BIO_get_fd(r, &ret); return (ret); } +LSSL_ALIAS(SSL_get_rfd); int SSL_get_wfd(const SSL *s) @@ -662,6 +689,7 @@ SSL_get_wfd(const SSL *s) BIO_get_fd(r, &ret); return (ret); } +LSSL_ALIAS(SSL_get_wfd); int SSL_set_fd(SSL *s, int fd) @@ -681,6 +709,7 @@ SSL_set_fd(SSL *s, int fd) err: return (ret); } +LSSL_ALIAS(SSL_set_fd); int SSL_set_wfd(SSL *s, int fd) @@ -704,6 +733,7 @@ SSL_set_wfd(SSL *s, int fd) err: return (ret); } +LSSL_ALIAS(SSL_set_wfd); int SSL_set_rfd(SSL *s, int fd) @@ -727,6 +757,7 @@ SSL_set_rfd(SSL *s, int fd) err: return (ret); } +LSSL_ALIAS(SSL_set_rfd); /* return length of latest Finished message we sent, copy to 'buf' */ @@ -741,6 +772,7 @@ SSL_get_finished(const SSL *s, void *buf, size_t count) memcpy(buf, s->s3->hs.finished, count); return (ret); } +LSSL_ALIAS(SSL_get_finished); /* return length of latest Finished message we expected, copy to 'buf' */ size_t @@ -754,6 +786,7 @@ SSL_get_peer_finished(const SSL *s, void *buf, size_t count) memcpy(buf, s->s3->hs.peer_finished, count); return (ret); } +LSSL_ALIAS(SSL_get_peer_finished); int @@ -761,30 +794,35 @@ SSL_get_verify_mode(const SSL *s) { return (s->verify_mode); } +LSSL_ALIAS(SSL_get_verify_mode); int SSL_get_verify_depth(const SSL *s) { return (X509_VERIFY_PARAM_get_depth(s->param)); } +LSSL_ALIAS(SSL_get_verify_depth); int (*SSL_get_verify_callback(const SSL *s))(int, X509_STORE_CTX *) { return (s->verify_callback); } +LSSL_ALIAS(SSL_get_verify_callback); void SSL_CTX_set_keylog_callback(SSL_CTX *ctx, SSL_CTX_keylog_cb_func cb) { ctx->keylog_callback = cb; } +LSSL_ALIAS(SSL_CTX_set_keylog_callback); SSL_CTX_keylog_cb_func SSL_CTX_get_keylog_callback(const SSL_CTX *ctx) { return (ctx->keylog_callback); } +LSSL_ALIAS(SSL_CTX_get_keylog_callback); int SSL_set_num_tickets(SSL *s, size_t num_tickets) @@ -793,12 +831,14 @@ SSL_set_num_tickets(SSL *s, size_t num_tickets) return 1; } +LSSL_ALIAS(SSL_set_num_tickets); size_t SSL_get_num_tickets(const SSL *s) { return s->num_tickets; } +LSSL_ALIAS(SSL_get_num_tickets); int SSL_CTX_set_num_tickets(SSL_CTX *ctx, size_t num_tickets) @@ -807,30 +847,35 @@ SSL_CTX_set_num_tickets(SSL_CTX *ctx, size_t num_tickets) return 1; } +LSSL_ALIAS(SSL_CTX_set_num_tickets); size_t SSL_CTX_get_num_tickets(const SSL_CTX *ctx) { return ctx->num_tickets; } +LSSL_ALIAS(SSL_CTX_get_num_tickets); int SSL_CTX_get_verify_mode(const SSL_CTX *ctx) { return (ctx->verify_mode); } +LSSL_ALIAS(SSL_CTX_get_verify_mode); int SSL_CTX_get_verify_depth(const SSL_CTX *ctx) { return (X509_VERIFY_PARAM_get_depth(ctx->param)); } +LSSL_ALIAS(SSL_CTX_get_verify_depth); int (*SSL_CTX_get_verify_callback(const SSL_CTX *ctx))(int, X509_STORE_CTX *) { return (ctx->default_verify_callback); } +LSSL_ALIAS(SSL_CTX_get_verify_callback); void SSL_set_verify(SSL *s, int mode, @@ -840,30 +885,35 @@ SSL_set_verify(SSL *s, int mode, if (callback != NULL) s->verify_callback = callback; } +LSSL_ALIAS(SSL_set_verify); void SSL_set_verify_depth(SSL *s, int depth) { X509_VERIFY_PARAM_set_depth(s->param, depth); } +LSSL_ALIAS(SSL_set_verify_depth); void SSL_set_read_ahead(SSL *s, int yes) { s->read_ahead = yes; } +LSSL_ALIAS(SSL_set_read_ahead); int SSL_get_read_ahead(const SSL *s) { return (s->read_ahead); } +LSSL_ALIAS(SSL_get_read_ahead); int SSL_pending(const SSL *s) { return (s->method->ssl_pending(s)); } +LSSL_ALIAS(SSL_pending); X509 * SSL_get_peer_certificate(const SSL *s) @@ -880,6 +930,7 @@ SSL_get_peer_certificate(const SSL *s) return cert; } +LSSL_ALIAS(SSL_get_peer_certificate); STACK_OF(X509) * SSL_get_peer_cert_chain(const SSL *s) @@ -896,6 +947,7 @@ SSL_get_peer_cert_chain(const SSL *s) return s->s3->hs.peer_certs_no_leaf; } +LSSL_ALIAS(SSL_get_peer_cert_chain); STACK_OF(X509) * SSL_get0_verified_chain(const SSL *s) @@ -904,6 +956,7 @@ SSL_get0_verified_chain(const SSL *s) return NULL; return s->s3->hs.verified_chain; } +LSSL_ALIAS(SSL_get0_verified_chain); /* * Now in theory, since the calling process own 't' it should be safe to @@ -939,6 +992,7 @@ SSL_copy_session_id(SSL *t, const SSL *f) return 1; } +LSSL_ALIAS(SSL_copy_session_id); /* Fix this so it checks all the valid key/cert options */ int @@ -956,6 +1010,7 @@ SSL_CTX_check_private_key(const SSL_CTX *ctx) return (X509_check_private_key(ctx->cert->key->x509, ctx->cert->key->privatekey)); } +LSSL_ALIAS(SSL_CTX_check_private_key); /* Fix this function so that it takes an optional type parameter */ int @@ -980,6 +1035,7 @@ SSL_check_private_key(const SSL *ssl) return (X509_check_private_key(ssl->cert->key->x509, ssl->cert->key->privatekey)); } +LSSL_ALIAS(SSL_check_private_key); int SSL_accept(SSL *s) @@ -989,6 +1045,7 @@ SSL_accept(SSL *s) return (s->method->ssl_accept(s)); } +LSSL_ALIAS(SSL_accept); int SSL_connect(SSL *s) @@ -998,18 +1055,21 @@ SSL_connect(SSL *s) return (s->method->ssl_connect(s)); } +LSSL_ALIAS(SSL_connect); int SSL_is_dtls(const SSL *s) { return s->method->dtls; } +LSSL_ALIAS(SSL_is_dtls); int SSL_is_server(const SSL *s) { return s->server; } +LSSL_ALIAS(SSL_is_server); static long ssl_get_default_timeout() @@ -1026,6 +1086,7 @@ SSL_get_default_timeout(const SSL *s) { return (ssl_get_default_timeout()); } +LSSL_ALIAS(SSL_get_default_timeout); int SSL_read(SSL *s, void *buf, int num) @@ -1051,6 +1112,7 @@ SSL_read(SSL *s, void *buf, int num) } return ssl3_read(s, buf, num); } +LSSL_ALIAS(SSL_read); int SSL_read_ex(SSL *s, void *buf, size_t num, size_t *bytes_read) @@ -1070,6 +1132,7 @@ SSL_read_ex(SSL *s, void *buf, size_t num, size_t *bytes_read) return ret > 0; } +LSSL_ALIAS(SSL_read_ex); int SSL_peek(SSL *s, void *buf, int num) @@ -1094,6 +1157,7 @@ SSL_peek(SSL *s, void *buf, int num) } return ssl3_peek(s, buf, num); } +LSSL_ALIAS(SSL_peek); int SSL_peek_ex(SSL *s, void *buf, size_t num, size_t *bytes_peeked) @@ -1113,6 +1177,7 @@ SSL_peek_ex(SSL *s, void *buf, size_t num, size_t *bytes_peeked) return ret > 0; } +LSSL_ALIAS(SSL_peek_ex); int SSL_write(SSL *s, const void *buf, int num) @@ -1139,6 +1204,7 @@ SSL_write(SSL *s, const void *buf, int num) } return ssl3_write(s, buf, num); } +LSSL_ALIAS(SSL_write); int SSL_write_ex(SSL *s, const void *buf, size_t num, size_t *bytes_written) @@ -1164,36 +1230,42 @@ SSL_write_ex(SSL *s, const void *buf, size_t num, size_t *bytes_written) return ret > 0; } +LSSL_ALIAS(SSL_write_ex); uint32_t SSL_CTX_get_max_early_data(const SSL_CTX *ctx) { return 0; } +LSSL_ALIAS(SSL_CTX_get_max_early_data); int SSL_CTX_set_max_early_data(SSL_CTX *ctx, uint32_t max_early_data) { return 1; } +LSSL_ALIAS(SSL_CTX_set_max_early_data); uint32_t SSL_get_max_early_data(const SSL *s) { return 0; } +LSSL_ALIAS(SSL_get_max_early_data); int SSL_set_max_early_data(SSL *s, uint32_t max_early_data) { return 1; } +LSSL_ALIAS(SSL_set_max_early_data); int SSL_get_early_data_status(const SSL *s) { return SSL_EARLY_DATA_REJECTED; } +LSSL_ALIAS(SSL_get_early_data_status); int SSL_read_early_data(SSL *s, void *buf, size_t num, size_t *readbytes) @@ -1207,6 +1279,7 @@ SSL_read_early_data(SSL *s, void *buf, size_t num, size_t *readbytes) return SSL_READ_EARLY_DATA_FINISH; } +LSSL_ALIAS(SSL_read_early_data); int SSL_write_early_data(SSL *s, const void *buf, size_t num, size_t *written) @@ -1215,6 +1288,7 @@ SSL_write_early_data(SSL *s, const void *buf, size_t num, size_t *written) SSLerror(s, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return 0; } +LSSL_ALIAS(SSL_write_early_data); int SSL_shutdown(SSL *s) @@ -1236,6 +1310,7 @@ SSL_shutdown(SSL *s) return (1); } +LSSL_ALIAS(SSL_shutdown); int SSL_renegotiate(SSL *s) @@ -1247,6 +1322,7 @@ SSL_renegotiate(SSL *s) return (s->method->ssl_renegotiate(s)); } +LSSL_ALIAS(SSL_renegotiate); int SSL_renegotiate_abbreviated(SSL *s) @@ -1258,6 +1334,7 @@ SSL_renegotiate_abbreviated(SSL *s) return (s->method->ssl_renegotiate(s)); } +LSSL_ALIAS(SSL_renegotiate_abbreviated); int SSL_renegotiate_pending(SSL *s) @@ -1268,6 +1345,7 @@ SSL_renegotiate_pending(SSL *s) */ return (s->renegotiate != 0); } +LSSL_ALIAS(SSL_renegotiate_pending); long SSL_ctrl(SSL *s, int cmd, long larg, void *parg) @@ -1325,6 +1403,7 @@ SSL_ctrl(SSL *s, int cmd, long larg, void *parg) return ssl3_ctrl(s, cmd, larg, parg); } } +LSSL_ALIAS(SSL_ctrl); long SSL_callback_ctrl(SSL *s, int cmd, void (*fp)(void)) @@ -1338,12 +1417,14 @@ SSL_callback_ctrl(SSL *s, int cmd, void (*fp)(void)) return (ssl3_callback_ctrl(s, cmd, fp)); } } +LSSL_ALIAS(SSL_callback_ctrl); struct lhash_st_SSL_SESSION * SSL_CTX_sessions(SSL_CTX *ctx) { return (ctx->sessions); } +LSSL_ALIAS(SSL_CTX_sessions); long SSL_CTX_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg) @@ -1423,6 +1504,7 @@ SSL_CTX_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg) return (ssl3_ctx_ctrl(ctx, cmd, larg, parg)); } } +LSSL_ALIAS(SSL_CTX_ctrl); long SSL_CTX_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp)(void)) @@ -1436,6 +1518,7 @@ SSL_CTX_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp)(void)) return (ssl3_ctx_callback_ctrl(ctx, cmd, fp)); } } +LSSL_ALIAS(SSL_CTX_callback_ctrl); int ssl_cipher_id_cmp(const SSL_CIPHER *a, const SSL_CIPHER *b) @@ -1459,6 +1542,7 @@ SSL_get_ciphers(const SSL *s) return (s->ctx->cipher_list); } +LSSL_ALIAS(SSL_get_ciphers); STACK_OF(SSL_CIPHER) * SSL_get_client_ciphers(const SSL *s) @@ -1467,6 +1551,7 @@ SSL_get_client_ciphers(const SSL *s) return NULL; return s->session->ciphers; } +LSSL_ALIAS(SSL_get_client_ciphers); STACK_OF(SSL_CIPHER) * SSL_get1_supported_ciphers(SSL *s) @@ -1504,6 +1589,7 @@ SSL_get1_supported_ciphers(SSL *s) sk_SSL_CIPHER_free(supported_ciphers); return NULL; } +LSSL_ALIAS(SSL_get1_supported_ciphers); /* See if we have any ECC cipher suites. */ int @@ -1544,6 +1630,7 @@ SSL_get_cipher_list(const SSL *s, int n) return (cipher->name); } +LSSL_ALIAS(SSL_get_cipher_list); STACK_OF(SSL_CIPHER) * SSL_CTX_get_ciphers(const SSL_CTX *ctx) @@ -1552,6 +1639,7 @@ SSL_CTX_get_ciphers(const SSL_CTX *ctx) return NULL; return ctx->cipher_list; } +LSSL_ALIAS(SSL_CTX_get_ciphers); /* Specify the ciphers to be used by default by the SSL_CTX. */ int @@ -1576,6 +1664,7 @@ SSL_CTX_set_cipher_list(SSL_CTX *ctx, const char *str) } return (1); } +LSSL_ALIAS(SSL_CTX_set_cipher_list); int SSL_CTX_set_ciphersuites(SSL_CTX *ctx, const char *str) @@ -1590,6 +1679,7 @@ SSL_CTX_set_ciphersuites(SSL_CTX *ctx, const char *str) return 1; } +LSSL_ALIAS(SSL_CTX_set_ciphersuites); /* Specify the ciphers to be used by the SSL. */ int @@ -1611,6 +1701,7 @@ SSL_set_cipher_list(SSL *s, const char *str) } return (1); } +LSSL_ALIAS(SSL_set_cipher_list); int SSL_set_ciphersuites(SSL *s, const char *str) @@ -1630,6 +1721,7 @@ SSL_set_ciphersuites(SSL *s, const char *str) return 1; } +LSSL_ALIAS(SSL_set_ciphersuites); char * SSL_get_shared_ciphers(const SSL *s, char *buf, int len) @@ -1671,6 +1763,7 @@ SSL_get_shared_ciphers(const SSL *s, char *buf, int len) *end = '\0'; return buf; } +LSSL_ALIAS(SSL_get_shared_ciphers); /* * Return a servername extension value if provided in Client Hello, or NULL. @@ -1686,6 +1779,7 @@ SSL_get_servername(const SSL *s, const int type) s->session->tlsext_hostname : s->tlsext_hostname); } +LSSL_ALIAS(SSL_get_servername); int SSL_get_servername_type(const SSL *s) @@ -1696,6 +1790,7 @@ SSL_get_servername_type(const SSL *s) return (TLSEXT_NAMETYPE_host_name); return (-1); } +LSSL_ALIAS(SSL_get_servername_type); /* * SSL_select_next_proto implements standard protocol selection. It is @@ -1749,6 +1844,7 @@ SSL_select_next_proto(unsigned char **out, unsigned char *outlen, *outlen = result[0]; return (status); } +LSSL_ALIAS(SSL_select_next_proto); /* SSL_get0_next_proto_negotiated is deprecated. */ void @@ -1758,6 +1854,7 @@ SSL_get0_next_proto_negotiated(const SSL *s, const unsigned char **data, *data = NULL; *len = 0; } +LSSL_ALIAS(SSL_get0_next_proto_negotiated); /* SSL_CTX_set_next_protos_advertised_cb is deprecated. */ void @@ -1765,6 +1862,7 @@ SSL_CTX_set_next_protos_advertised_cb(SSL_CTX *ctx, int (*cb) (SSL *ssl, const unsigned char **out, unsigned int *outlen, void *arg), void *arg) { } +LSSL_ALIAS(SSL_CTX_set_next_protos_advertised_cb); /* SSL_CTX_set_next_proto_select_cb is deprecated. */ void @@ -1773,6 +1871,7 @@ SSL_CTX_set_next_proto_select_cb(SSL_CTX *ctx, int (*cb) (SSL *s, unsigned int inlen, void *arg), void *arg) { } +LSSL_ALIAS(SSL_CTX_set_next_proto_select_cb); /* * SSL_CTX_set_alpn_protos sets the ALPN protocol list to the specified @@ -1806,6 +1905,7 @@ SSL_CTX_set_alpn_protos(SSL_CTX *ctx, const unsigned char *protos, /* NOTE: Return values are the reverse of what you expect. */ return failed; } +LSSL_ALIAS(SSL_CTX_set_alpn_protos); /* * SSL_set_alpn_protos sets the ALPN protocol list to the specified @@ -1839,6 +1939,7 @@ SSL_set_alpn_protos(SSL *ssl, const unsigned char *protos, /* NOTE: Return values are the reverse of what you expect. */ return failed; } +LSSL_ALIAS(SSL_set_alpn_protos); /* * SSL_CTX_set_alpn_select_cb sets a callback function that is called during @@ -1853,6 +1954,7 @@ SSL_CTX_set_alpn_select_cb(SSL_CTX* ctx, ctx->alpn_select_cb = cb; ctx->alpn_select_cb_arg = arg; } +LSSL_ALIAS(SSL_CTX_set_alpn_select_cb); /* * SSL_get0_alpn_selected gets the selected ALPN protocol (if any). On return @@ -1867,12 +1969,14 @@ SSL_get0_alpn_selected(const SSL *ssl, const unsigned char **data, *data = ssl->s3->alpn_selected; *len = ssl->s3->alpn_selected_len; } +LSSL_ALIAS(SSL_get0_alpn_selected); void SSL_set_psk_use_session_callback(SSL *s, SSL_psk_use_session_cb_func cb) { return; } +LSSL_ALIAS(SSL_set_psk_use_session_callback); int SSL_export_keying_material(SSL *s, unsigned char *out, size_t out_len, @@ -1891,6 +1995,7 @@ SSL_export_keying_material(SSL *s, unsigned char *out, size_t out_len, return tls12_exporter(s, label, label_len, context, context_len, use_context, out, out_len); } +LSSL_ALIAS(SSL_export_keying_material); static unsigned long ssl_session_hash(const SSL_SESSION *a) @@ -2092,6 +2197,7 @@ SSL_CTX_new(const SSL_METHOD *meth) SSL_CTX_free(ret); return (NULL); } +LSSL_ALIAS(SSL_CTX_new); void SSL_CTX_free(SSL_CTX *ctx) @@ -2146,6 +2252,7 @@ SSL_CTX_free(SSL_CTX *ctx) free(ctx); } +LSSL_ALIAS(SSL_CTX_free); int SSL_CTX_up_ref(SSL_CTX *ctx) @@ -2153,30 +2260,35 @@ SSL_CTX_up_ref(SSL_CTX *ctx) int refs = CRYPTO_add(&ctx->references, 1, CRYPTO_LOCK_SSL_CTX); return ((refs > 1) ? 1 : 0); } +LSSL_ALIAS(SSL_CTX_up_ref); pem_password_cb * SSL_CTX_get_default_passwd_cb(SSL_CTX *ctx) { return (ctx->default_passwd_callback); } +LSSL_ALIAS(SSL_CTX_get_default_passwd_cb); void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, pem_password_cb *cb) { ctx->default_passwd_callback = cb; } +LSSL_ALIAS(SSL_CTX_set_default_passwd_cb); void * SSL_CTX_get_default_passwd_cb_userdata(SSL_CTX *ctx) { return ctx->default_passwd_callback_userdata; } +LSSL_ALIAS(SSL_CTX_get_default_passwd_cb_userdata); void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *ctx, void *u) { ctx->default_passwd_callback_userdata = u; } +LSSL_ALIAS(SSL_CTX_set_default_passwd_cb_userdata); void SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx, @@ -2185,6 +2297,7 @@ SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx, ctx->app_verify_callback = cb; ctx->app_verify_arg = arg; } +LSSL_ALIAS(SSL_CTX_set_cert_verify_callback); void SSL_CTX_set_verify(SSL_CTX *ctx, int mode, int (*cb)(int, X509_STORE_CTX *)) @@ -2192,12 +2305,14 @@ SSL_CTX_set_verify(SSL_CTX *ctx, int mode, int (*cb)(int, X509_STORE_CTX *)) ctx->verify_mode = mode; ctx->default_verify_callback = cb; } +LSSL_ALIAS(SSL_CTX_set_verify); void SSL_CTX_set_verify_depth(SSL_CTX *ctx, int depth) { X509_VERIFY_PARAM_set_depth(ctx->param, depth); } +LSSL_ALIAS(SSL_CTX_set_verify_depth); void ssl_set_cert_masks(SSL_CERT *c, const SSL_CIPHER *cipher) @@ -2478,6 +2593,7 @@ SSL_get_ssl_method(SSL *s) { return (s->method); } +LSSL_ALIAS(SSL_get_ssl_method); int SSL_set_ssl_method(SSL *s, const SSL_METHOD *method) @@ -2504,6 +2620,7 @@ SSL_set_ssl_method(SSL *s, const SSL_METHOD *method) return (ret); } +LSSL_ALIAS(SSL_set_ssl_method); int SSL_get_error(const SSL *s, int i) @@ -2583,6 +2700,7 @@ SSL_get_error(const SSL *s, int i) return (SSL_ERROR_SYSCALL); } +LSSL_ALIAS(SSL_get_error); int SSL_CTX_set_quic_method(SSL_CTX *ctx, const SSL_QUIC_METHOD *quic_method) @@ -2594,6 +2712,7 @@ SSL_CTX_set_quic_method(SSL_CTX *ctx, const SSL_QUIC_METHOD *quic_method) return 1; } +LSSL_ALIAS(SSL_CTX_set_quic_method); int SSL_set_quic_method(SSL *ssl, const SSL_QUIC_METHOD *quic_method) @@ -2605,6 +2724,7 @@ SSL_set_quic_method(SSL *ssl, const SSL_QUIC_METHOD *quic_method) return 1; } +LSSL_ALIAS(SSL_set_quic_method); size_t SSL_quic_max_handshake_flight_len(const SSL *ssl, @@ -2652,18 +2772,21 @@ SSL_quic_max_handshake_flight_len(const SSL *ssl, return 0; } +LSSL_ALIAS(SSL_quic_max_handshake_flight_len); enum ssl_encryption_level_t SSL_quic_read_level(const SSL *ssl) { return ssl->s3->hs.tls13.quic_read_level; } +LSSL_ALIAS(SSL_quic_read_level); enum ssl_encryption_level_t SSL_quic_write_level(const SSL *ssl) { return ssl->s3->hs.tls13.quic_write_level; } +LSSL_ALIAS(SSL_quic_write_level); int SSL_provide_quic_data(SSL *ssl, enum ssl_encryption_level_t level, @@ -2697,6 +2820,7 @@ SSL_provide_quic_data(SSL *ssl, enum ssl_encryption_level_t level, */ return tls_buffer_append(ssl->s3->hs.tls13.quic_read_buffer, data, len); } +LSSL_ALIAS(SSL_provide_quic_data); int SSL_process_quic_post_handshake(SSL *ssl) @@ -2704,6 +2828,7 @@ SSL_process_quic_post_handshake(SSL *ssl) /* XXX - this needs to run PHH received. */ return 1; } +LSSL_ALIAS(SSL_process_quic_post_handshake); int SSL_do_handshake(SSL *s) @@ -2720,6 +2845,7 @@ SSL_do_handshake(SSL *s) return s->handshake_func(s); } +LSSL_ALIAS(SSL_do_handshake); /* * For the next 2 functions, SSL_clear() sets shutdown and so @@ -2734,6 +2860,7 @@ SSL_set_accept_state(SSL *s) s->handshake_func = s->method->ssl_accept; ssl_clear_cipher_state(s); } +LSSL_ALIAS(SSL_set_accept_state); void SSL_set_connect_state(SSL *s) @@ -2744,6 +2871,7 @@ SSL_set_connect_state(SSL *s) s->handshake_func = s->method->ssl_connect; ssl_clear_cipher_state(s); } +LSSL_ALIAS(SSL_set_connect_state); int ssl_undefined_function(SSL *s) @@ -2792,6 +2920,7 @@ SSL_get_version(const SSL *s) { return ssl_version_string(s->version); } +LSSL_ALIAS(SSL_get_version); SSL * SSL_dup(SSL *s) @@ -2915,6 +3044,7 @@ SSL_dup(SSL *s) SSL_free(ret); return NULL; } +LSSL_ALIAS(SSL_dup); void ssl_clear_cipher_state(SSL *s) @@ -2957,6 +3087,7 @@ SSL_get_certificate(const SSL *s) { return (s->cert->key->x509); } +LSSL_ALIAS(SSL_get_certificate); /* Fix this function so that it takes an optional type parameter */ EVP_PKEY * @@ -2964,6 +3095,7 @@ SSL_get_privatekey(const SSL *s) { return (s->cert->key->privatekey); } +LSSL_ALIAS(SSL_get_privatekey); const SSL_CIPHER * SSL_get_current_cipher(const SSL *s) @@ -2972,17 +3104,20 @@ SSL_get_current_cipher(const SSL *s) return (s->session->cipher); return (NULL); } +LSSL_ALIAS(SSL_get_current_cipher); const void * SSL_get_current_compression(SSL *s) { return (NULL); } +LSSL_ALIAS(SSL_get_current_compression); const void * SSL_get_current_expansion(SSL *s) { return (NULL); } +LSSL_ALIAS(SSL_get_current_expansion); size_t SSL_get_client_random(const SSL *s, unsigned char *out, size_t max_out) @@ -2999,6 +3134,7 @@ SSL_get_client_random(const SSL *s, unsigned char *out, size_t max_out) return len; } +LSSL_ALIAS(SSL_get_client_random); size_t SSL_get_server_random(const SSL *s, unsigned char *out, size_t max_out) @@ -3015,6 +3151,7 @@ SSL_get_server_random(const SSL *s, unsigned char *out, size_t max_out) return len; } +LSSL_ALIAS(SSL_get_server_random); int ssl_init_wbio_buffer(SSL *s, int push) @@ -3069,48 +3206,56 @@ SSL_CTX_set_quiet_shutdown(SSL_CTX *ctx, int mode) { ctx->quiet_shutdown = mode; } +LSSL_ALIAS(SSL_CTX_set_quiet_shutdown); int SSL_CTX_get_quiet_shutdown(const SSL_CTX *ctx) { return (ctx->quiet_shutdown); } +LSSL_ALIAS(SSL_CTX_get_quiet_shutdown); void SSL_set_quiet_shutdown(SSL *s, int mode) { s->quiet_shutdown = mode; } +LSSL_ALIAS(SSL_set_quiet_shutdown); int SSL_get_quiet_shutdown(const SSL *s) { return (s->quiet_shutdown); } +LSSL_ALIAS(SSL_get_quiet_shutdown); void SSL_set_shutdown(SSL *s, int mode) { s->shutdown = mode; } +LSSL_ALIAS(SSL_set_shutdown); int SSL_get_shutdown(const SSL *s) { return (s->shutdown); } +LSSL_ALIAS(SSL_get_shutdown); int SSL_version(const SSL *s) { return (s->version); } +LSSL_ALIAS(SSL_version); SSL_CTX * SSL_get_SSL_CTX(const SSL *ssl) { return (ssl->ctx); } +LSSL_ALIAS(SSL_get_SSL_CTX); SSL_CTX * SSL_set_SSL_CTX(SSL *ssl, SSL_CTX* ctx) @@ -3133,12 +3278,14 @@ SSL_set_SSL_CTX(SSL *ssl, SSL_CTX* ctx) return (ssl->ctx); } +LSSL_ALIAS(SSL_set_SSL_CTX); int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx) { return (X509_STORE_set_default_paths(ctx->cert_store)); } +LSSL_ALIAS(SSL_CTX_set_default_verify_paths); int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile, @@ -3146,18 +3293,21 @@ SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile, { return (X509_STORE_load_locations(ctx->cert_store, CAfile, CApath)); } +LSSL_ALIAS(SSL_CTX_load_verify_locations); int SSL_CTX_load_verify_mem(SSL_CTX *ctx, void *buf, int len) { return (X509_STORE_load_mem(ctx->cert_store, buf, len)); } +LSSL_ALIAS(SSL_CTX_load_verify_mem); void SSL_set_info_callback(SSL *ssl, void (*cb)(const SSL *ssl, int type, int val)) { ssl->info_callback = cb; } +LSSL_ALIAS(SSL_set_info_callback); void (*SSL_get_info_callback(const SSL *ssl))(const SSL *ssl, int type, int val) { @@ -3169,42 +3319,49 @@ SSL_state(const SSL *ssl) { return (ssl->s3->hs.state); } +LSSL_ALIAS(SSL_state); void SSL_set_state(SSL *ssl, int state) { ssl->s3->hs.state = state; } +LSSL_ALIAS(SSL_set_state); void SSL_set_verify_result(SSL *ssl, long arg) { ssl->verify_result = arg; } +LSSL_ALIAS(SSL_set_verify_result); long SSL_get_verify_result(const SSL *ssl) { return (ssl->verify_result); } +LSSL_ALIAS(SSL_get_verify_result); int SSL_verify_client_post_handshake(SSL *ssl) { return 0; } +LSSL_ALIAS(SSL_verify_client_post_handshake); void SSL_CTX_set_post_handshake_auth(SSL_CTX *ctx, int val) { return; } +LSSL_ALIAS(SSL_CTX_set_post_handshake_auth); void SSL_set_post_handshake_auth(SSL *ssl, int val) { return; } +LSSL_ALIAS(SSL_set_post_handshake_auth); int SSL_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, @@ -3213,18 +3370,21 @@ SSL_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, return (CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL, argl, argp, new_func, dup_func, free_func)); } +LSSL_ALIAS(SSL_get_ex_new_index); int SSL_set_ex_data(SSL *s, int idx, void *arg) { return (CRYPTO_set_ex_data(&s->ex_data, idx, arg)); } +LSSL_ALIAS(SSL_set_ex_data); void * SSL_get_ex_data(const SSL *s, int idx) { return (CRYPTO_get_ex_data(&s->ex_data, idx)); } +LSSL_ALIAS(SSL_get_ex_data); int SSL_CTX_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, @@ -3233,18 +3393,21 @@ SSL_CTX_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, return (CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL_CTX, argl, argp, new_func, dup_func, free_func)); } +LSSL_ALIAS(SSL_CTX_get_ex_new_index); int SSL_CTX_set_ex_data(SSL_CTX *s, int idx, void *arg) { return (CRYPTO_set_ex_data(&s->ex_data, idx, arg)); } +LSSL_ALIAS(SSL_CTX_set_ex_data); void * SSL_CTX_get_ex_data(const SSL_CTX *s, int idx) { return (CRYPTO_get_ex_data(&s->ex_data, idx)); } +LSSL_ALIAS(SSL_CTX_get_ex_data); int ssl_ok(SSL *s) @@ -3257,6 +3420,7 @@ SSL_CTX_get_cert_store(const SSL_CTX *ctx) { return (ctx->cert_store); } +LSSL_ALIAS(SSL_CTX_get_cert_store); void SSL_CTX_set_cert_store(SSL_CTX *ctx, X509_STORE *store) @@ -3264,6 +3428,7 @@ SSL_CTX_set_cert_store(SSL_CTX *ctx, X509_STORE *store) X509_STORE_free(ctx->cert_store); ctx->cert_store = store; } +LSSL_ALIAS(SSL_CTX_set_cert_store); X509 * SSL_CTX_get0_certificate(const SSL_CTX *ctx) @@ -3273,6 +3438,7 @@ SSL_CTX_get0_certificate(const SSL_CTX *ctx) return ctx->cert->key->x509; } +LSSL_ALIAS(SSL_CTX_get0_certificate); EVP_PKEY * SSL_CTX_get0_privatekey(const SSL_CTX *ctx) @@ -3282,12 +3448,14 @@ SSL_CTX_get0_privatekey(const SSL_CTX *ctx) return ctx->cert->key->privatekey; } +LSSL_ALIAS(SSL_CTX_get0_privatekey); int SSL_want(const SSL *s) { return (s->rwstate); } +LSSL_ALIAS(SSL_want); void SSL_CTX_set_tmp_rsa_callback(SSL_CTX *ctx, RSA *(*cb)(SSL *ssl, int is_export, @@ -3295,6 +3463,7 @@ SSL_CTX_set_tmp_rsa_callback(SSL_CTX *ctx, RSA *(*cb)(SSL *ssl, int is_export, { SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_TMP_RSA_CB,(void (*)(void))cb); } +LSSL_ALIAS(SSL_CTX_set_tmp_rsa_callback); void SSL_set_tmp_rsa_callback(SSL *ssl, RSA *(*cb)(SSL *ssl, int is_export, @@ -3302,6 +3471,7 @@ SSL_set_tmp_rsa_callback(SSL *ssl, RSA *(*cb)(SSL *ssl, int is_export, { SSL_callback_ctrl(ssl, SSL_CTRL_SET_TMP_RSA_CB,(void (*)(void))cb); } +LSSL_ALIAS(SSL_set_tmp_rsa_callback); void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx, DH *(*dh)(SSL *ssl, int is_export, @@ -3309,6 +3479,7 @@ SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx, DH *(*dh)(SSL *ssl, int is_export, { SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_TMP_DH_CB,(void (*)(void))dh); } +LSSL_ALIAS(SSL_CTX_set_tmp_dh_callback); void SSL_set_tmp_dh_callback(SSL *ssl, DH *(*dh)(SSL *ssl, int is_export, @@ -3316,6 +3487,7 @@ SSL_set_tmp_dh_callback(SSL *ssl, DH *(*dh)(SSL *ssl, int is_export, { SSL_callback_ctrl(ssl, SSL_CTRL_SET_TMP_DH_CB,(void (*)(void))dh); } +LSSL_ALIAS(SSL_set_tmp_dh_callback); void SSL_CTX_set_tmp_ecdh_callback(SSL_CTX *ctx, EC_KEY *(*ecdh)(SSL *ssl, @@ -3324,6 +3496,7 @@ SSL_CTX_set_tmp_ecdh_callback(SSL_CTX *ctx, EC_KEY *(*ecdh)(SSL *ssl, SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_TMP_ECDH_CB, (void (*)(void))ecdh); } +LSSL_ALIAS(SSL_CTX_set_tmp_ecdh_callback); void SSL_set_tmp_ecdh_callback(SSL *ssl, EC_KEY *(*ecdh)(SSL *ssl, int is_export, @@ -3331,6 +3504,7 @@ SSL_set_tmp_ecdh_callback(SSL *ssl, EC_KEY *(*ecdh)(SSL *ssl, int is_export, { SSL_callback_ctrl(ssl, SSL_CTRL_SET_TMP_ECDH_CB,(void (*)(void))ecdh); } +LSSL_ALIAS(SSL_set_tmp_ecdh_callback); void @@ -3340,6 +3514,7 @@ SSL_CTX_set_msg_callback(SSL_CTX *ctx, void (*cb)(int write_p, int version, SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb); } +LSSL_ALIAS(SSL_CTX_set_msg_callback); void SSL_set_msg_callback(SSL *ssl, void (*cb)(int write_p, int version, @@ -3347,24 +3522,28 @@ SSL_set_msg_callback(SSL *ssl, void (*cb)(int write_p, int version, { SSL_callback_ctrl(ssl, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb); } +LSSL_ALIAS(SSL_set_msg_callback); void SSL_set_debug(SSL *s, int debug) { s->debug = debug; } +LSSL_ALIAS(SSL_set_debug); int SSL_cache_hit(SSL *s) { return (s->hit); } +LSSL_ALIAS(SSL_cache_hit); int SSL_CTX_get_min_proto_version(SSL_CTX *ctx) { return ctx->min_proto_version; } +LSSL_ALIAS(SSL_CTX_get_min_proto_version); int SSL_CTX_set_min_proto_version(SSL_CTX *ctx, uint16_t version) @@ -3373,12 +3552,14 @@ SSL_CTX_set_min_proto_version(SSL_CTX *ctx, uint16_t version) ctx->max_tls_version, &ctx->min_tls_version, &ctx->min_proto_version); } +LSSL_ALIAS(SSL_CTX_set_min_proto_version); int SSL_CTX_get_max_proto_version(SSL_CTX *ctx) { return ctx->max_proto_version; } +LSSL_ALIAS(SSL_CTX_get_max_proto_version); int SSL_CTX_set_max_proto_version(SSL_CTX *ctx, uint16_t version) @@ -3387,12 +3568,14 @@ SSL_CTX_set_max_proto_version(SSL_CTX *ctx, uint16_t version) ctx->min_tls_version, &ctx->max_tls_version, &ctx->max_proto_version); } +LSSL_ALIAS(SSL_CTX_set_max_proto_version); int SSL_get_min_proto_version(SSL *ssl) { return ssl->min_proto_version; } +LSSL_ALIAS(SSL_get_min_proto_version); int SSL_set_min_proto_version(SSL *ssl, uint16_t version) @@ -3401,11 +3584,13 @@ SSL_set_min_proto_version(SSL *ssl, uint16_t version) ssl->max_tls_version, &ssl->min_tls_version, &ssl->min_proto_version); } +LSSL_ALIAS(SSL_set_min_proto_version); int SSL_get_max_proto_version(SSL *ssl) { return ssl->max_proto_version; } +LSSL_ALIAS(SSL_get_max_proto_version); int SSL_set_max_proto_version(SSL *ssl, uint16_t version) @@ -3414,42 +3599,49 @@ SSL_set_max_proto_version(SSL *ssl, uint16_t version) ssl->min_tls_version, &ssl->max_tls_version, &ssl->max_proto_version); } +LSSL_ALIAS(SSL_set_max_proto_version); const SSL_METHOD * SSL_CTX_get_ssl_method(const SSL_CTX *ctx) { return ctx->method; } +LSSL_ALIAS(SSL_CTX_get_ssl_method); int SSL_CTX_get_security_level(const SSL_CTX *ctx) { return ctx->cert->security_level; } +LSSL_ALIAS(SSL_CTX_get_security_level); void SSL_CTX_set_security_level(SSL_CTX *ctx, int level) { ctx->cert->security_level = level; } +LSSL_ALIAS(SSL_CTX_set_security_level); int SSL_get_security_level(const SSL *ssl) { return ssl->cert->security_level; } +LSSL_ALIAS(SSL_get_security_level); void SSL_set_security_level(SSL *ssl, int level) { ssl->cert->security_level = level; } +LSSL_ALIAS(SSL_set_security_level); int SSL_is_quic(const SSL *ssl) { return ssl->quic_method != NULL; } +LSSL_ALIAS(SSL_is_quic); int SSL_set_quic_transport_params(SSL *ssl, const uint8_t *params, @@ -3468,6 +3660,7 @@ SSL_set_quic_transport_params(SSL *ssl, const uint8_t *params, return 1; } +LSSL_ALIAS(SSL_set_quic_transport_params); void SSL_get_peer_quic_transport_params(const SSL *ssl, const uint8_t **out_params, @@ -3476,12 +3669,14 @@ SSL_get_peer_quic_transport_params(const SSL *ssl, const uint8_t **out_params, *out_params = ssl->s3->peer_quic_transport_params; *out_params_len = ssl->s3->peer_quic_transport_params_len; } +LSSL_ALIAS(SSL_get_peer_quic_transport_params); void SSL_set_quic_use_legacy_codepoint(SSL *ssl, int use_legacy) { /* Not supported. */ } +LSSL_ALIAS(SSL_set_quic_use_legacy_codepoint); static int ssl_cipher_id_cmp_BSEARCH_CMP_FN(const void *a_, const void *b_) -- cgit v1.2.3-55-g6feb