.gitignore

@@ -1 +1,2 @@
-SOURCES/libssh-0.11.1.tar.xz
+SOURCES/libssh-0.10.4.tar.xz
+SOURCES/libssh.keyring

.libssh.metadata

@@ -1 +1,2 @@
-1ddc90daacc4aedd3ab1c5407adc44925e0ba28e SOURCES/libssh-0.11.1.tar.xz
+4c48350a0a688ad82080175ed26a2019928a99c4 SOURCES/libssh-0.10.4.tar.xz
+3f2ab0bca02893402ba0ad172a6bd44456a65f86 SOURCES/libssh.keyring

SOURCES/CVE-2023-48795.patch

@@ -0,0 +1,729 @@
+From 4cef5e965a46e9271aed62631b152e4bd23c1e3c Mon Sep 17 00:00:00 2001
+From: Aris Adamantiadis <aris@0xbadc0de.be>
+Date: Tue, 12 Dec 2023 23:09:57 +0100
+Subject: [PATCH 1/4] CVE-2023-48795: client side mitigation
+
+Signed-off-by: Aris Adamantiadis <aris@0xbadc0de.be>
+Signed-off-by: Jakub Jelen <jjelen@redhat.com>
+Reviewed-by: Andreas Schneider <asn@cryptomilk.org>
+---
+ include/libssh/packet.h  |  1 +
+ include/libssh/session.h |  6 +++++
+ src/curve25519.c         | 19 +++----------
+ src/dh-gex.c             |  7 +----
+ src/dh.c                 | 17 +++---------
+ src/ecdh.c               |  8 +-----
+ src/ecdh_crypto.c        | 12 +++------
+ src/ecdh_gcrypt.c        | 10 +++----
+ src/ecdh_mbedcrypto.c    | 11 +++-----
+ src/kex.c                | 34 +++++++++++++++++++----
+ src/packet.c             | 58 ++++++++++++++++++++++++++++++++++++++++
+ src/packet_cb.c          | 12 +++++++++
+ 12 files changed, 126 insertions(+), 69 deletions(-)
+
+diff --git a/include/libssh/packet.h b/include/libssh/packet.h
+index 7f10a709..f0c8cb20 100644
+--- a/include/libssh/packet.h
++++ b/include/libssh/packet.h
+@@ -67,6 +67,7 @@ SSH_PACKET_CALLBACK(ssh_packet_ext_info);
+ SSH_PACKET_CALLBACK(ssh_packet_kexdh_init);
+ #endif
+ 
++int ssh_packet_send_newkeys(ssh_session session);
+ int ssh_packet_send_unimplemented(ssh_session session, uint32_t seqnum);
+ int ssh_packet_parse_type(ssh_session session);
+ //int packet_flush(ssh_session session, int enforce_blocking);
+diff --git a/include/libssh/session.h b/include/libssh/session.h
+index eb14e97a..97936195 100644
+--- a/include/libssh/session.h
++++ b/include/libssh/session.h
+@@ -81,6 +81,12 @@ enum ssh_pending_call_e {
+  * sending it twice during key exchange to simplify the state machine. */
+ #define SSH_SESSION_FLAG_KEXINIT_SENT 4
+ 
++/* The current SSH2 session implements the "strict KEX" feature and should behave
++ * differently on SSH2_MSG_NEWKEYS. */
++#define SSH_SESSION_FLAG_KEX_STRICT 0x0010
++/* Unexpected packets have been sent while the session was still unencrypted */
++#define SSH_SESSION_FLAG_KEX_TAINTED 0x0020
++
+ /* codes to use with ssh_handle_packets*() */
+ /* Infinite timeout */
+ #define SSH_TIMEOUT_INFINITE -1
+diff --git a/src/curve25519.c b/src/curve25519.c
+index 66291b5f..4aeb4756 100644
+--- a/src/curve25519.c
++++ b/src/curve25519.c
+@@ -335,16 +335,10 @@ static SSH_PACKET_CALLBACK(ssh_packet_client_curve25519_reply){
+   }
+ 
+   /* Send the MSG_NEWKEYS */
+-  if (ssh_buffer_add_u8(session->out_buffer, SSH2_MSG_NEWKEYS) < 0) {
+-    goto error;
+-  }
+-
+-  rc=ssh_packet_send(session);
++  rc = ssh_packet_send_newkeys(session);
+   if (rc == SSH_ERROR) {
+     goto error;
+   }
+-
+-  SSH_LOG(SSH_LOG_DEBUG, "SSH_MSG_NEWKEYS sent");
+   session->dh_handshake_state = DH_STATE_NEWKEYS_SENT;
+ 
+   return SSH_PACKET_USED;
+@@ -502,18 +496,13 @@ static SSH_PACKET_CALLBACK(ssh_packet_server_curve25519_init){
+         return SSH_ERROR;
+     }
+ 
+-    /* Send the MSG_NEWKEYS */
+-    rc = ssh_buffer_add_u8(session->out_buffer, SSH2_MSG_NEWKEYS);
+-    if (rc < 0) {
+-        goto error;
+-    }
+-
+     session->dh_handshake_state = DH_STATE_NEWKEYS_SENT;
+-    rc = ssh_packet_send(session);
++
++    /* Send the MSG_NEWKEYS */
++    rc = ssh_packet_send_newkeys(session);
+     if (rc == SSH_ERROR) {
+         goto error;
+     }
+-    SSH_LOG(SSH_LOG_DEBUG, "SSH_MSG_NEWKEYS sent");
+ 
+     return SSH_PACKET_USED;
+ error:
+diff --git a/src/dh-gex.c b/src/dh-gex.c
+index 91617081..642a88ae 100644
+--- a/src/dh-gex.c
++++ b/src/dh-gex.c
+@@ -297,15 +297,10 @@ static SSH_PACKET_CALLBACK(ssh_packet_client_dhgex_reply)
+     }
+ 
+     /* Send the MSG_NEWKEYS */
+-    if (ssh_buffer_add_u8(session->out_buffer, SSH2_MSG_NEWKEYS) < 0) {
+-        goto error;
+-    }
+-
+-    rc = ssh_packet_send(session);
++    rc = ssh_packet_send_newkeys(session);
+     if (rc == SSH_ERROR) {
+         goto error;
+     }
+-    SSH_LOG(SSH_LOG_DEBUG, "SSH_MSG_NEWKEYS sent");
+     session->dh_handshake_state = DH_STATE_NEWKEYS_SENT;
+ 
+     return SSH_PACKET_USED;
+diff --git a/src/dh.c b/src/dh.c
+index 011d97b3..e19e43d1 100644
+--- a/src/dh.c
++++ b/src/dh.c
+@@ -398,16 +398,10 @@ SSH_PACKET_CALLBACK(ssh_packet_client_dh_reply){
+   }
+ 
+   /* Send the MSG_NEWKEYS */
+-  if (ssh_buffer_add_u8(session->out_buffer, SSH2_MSG_NEWKEYS) < 0) {
+-    goto error;
+-  }
+-
+-  rc=ssh_packet_send(session);
++  rc = ssh_packet_send_newkeys(session);
+   if (rc == SSH_ERROR) {
+     goto error;
+   }
+-
+-  SSH_LOG(SSH_LOG_DEBUG, "SSH_MSG_NEWKEYS sent");
+   session->dh_handshake_state = DH_STATE_NEWKEYS_SENT;
+   return SSH_PACKET_USED;
+ error:
+@@ -551,15 +545,12 @@ int ssh_server_dh_process_init(ssh_session session, ssh_buffer packet)
+     }
+     SSH_LOG(SSH_LOG_DEBUG, "Sent KEX_DH_[GEX]_REPLY");
+ 
+-    if (ssh_buffer_add_u8(session->out_buffer, SSH2_MSG_NEWKEYS) < 0) {
+-        ssh_buffer_reinit(session->out_buffer);
+-        goto error;
+-    }
+     session->dh_handshake_state=DH_STATE_NEWKEYS_SENT;
+-    if (ssh_packet_send(session) == SSH_ERROR) {
++    /* Send the MSG_NEWKEYS */
++    rc = ssh_packet_send_newkeys(session);
++    if (rc == SSH_ERROR) {
+         goto error;
+     }
+-    SSH_LOG(SSH_LOG_PACKET, "SSH_MSG_NEWKEYS sent");
+ 
+     return SSH_OK;
+ error:
+diff --git a/src/ecdh.c b/src/ecdh.c
+index e5b11ba9..af80beec 100644
+--- a/src/ecdh.c
++++ b/src/ecdh.c
+@@ -93,16 +93,10 @@ SSH_PACKET_CALLBACK(ssh_packet_client_ecdh_reply){
+   }
+ 
+   /* Send the MSG_NEWKEYS */
+-  if (ssh_buffer_add_u8(session->out_buffer, SSH2_MSG_NEWKEYS) < 0) {
+-    goto error;
+-  }
+-
+-  rc=ssh_packet_send(session);
++  rc = ssh_packet_send_newkeys(session);
+   if (rc == SSH_ERROR) {
+     goto error;
+   }
+-
+-  SSH_LOG(SSH_LOG_DEBUG, "SSH_MSG_NEWKEYS sent");
+   session->dh_handshake_state = DH_STATE_NEWKEYS_SENT;
+ 
+   return SSH_PACKET_USED;
+diff --git a/src/ecdh_crypto.c b/src/ecdh_crypto.c
+index 51084b7a..069b1372 100644
+--- a/src/ecdh_crypto.c
++++ b/src/ecdh_crypto.c
+@@ -619,18 +619,12 @@ SSH_PACKET_CALLBACK(ssh_packet_server_ecdh_init){
+         goto error;
+     }
+ 
+-    /* Send the MSG_NEWKEYS */
+-    rc = ssh_buffer_add_u8(session->out_buffer, SSH2_MSG_NEWKEYS);
+-    if (rc < 0) {
+-        goto error;
+-    }
+-
+     session->dh_handshake_state = DH_STATE_NEWKEYS_SENT;
+-    rc = ssh_packet_send(session);
+-    if (rc == SSH_ERROR){
++    /* Send the MSG_NEWKEYS */
++    rc = ssh_packet_send_newkeys(session);
++    if (rc == SSH_ERROR) {
+         goto error;
+     }
+-    SSH_LOG(SSH_LOG_DEBUG, "SSH_MSG_NEWKEYS sent");
+ 
+     return SSH_PACKET_USED;
+ error:
+diff --git a/src/ecdh_gcrypt.c b/src/ecdh_gcrypt.c
+index 235f2904..3d9d426f 100644
+--- a/src/ecdh_gcrypt.c
++++ b/src/ecdh_gcrypt.c
+@@ -372,17 +372,13 @@ SSH_PACKET_CALLBACK(ssh_packet_server_ecdh_init){
+         goto out;
+     }
+ 
+-
++    session->dh_handshake_state = DH_STATE_NEWKEYS_SENT;
+     /* Send the MSG_NEWKEYS */
+-    rc = ssh_buffer_add_u8(session->out_buffer, SSH2_MSG_NEWKEYS);
+-    if (rc != SSH_OK) {
++    rc = ssh_packet_send_newkeys(session);
++    if (rc == SSH_ERROR) {
+         goto out;
+     }
+ 
+-    session->dh_handshake_state = DH_STATE_NEWKEYS_SENT;
+-    rc = ssh_packet_send(session);
+-    SSH_LOG(SSH_LOG_DEBUG, "SSH_MSG_NEWKEYS sent");
+-
+  out:
+     gcry_sexp_release(param);
+     gcry_sexp_release(key);
+diff --git a/src/ecdh_mbedcrypto.c b/src/ecdh_mbedcrypto.c
+index cfe017a0..dda73922 100644
+--- a/src/ecdh_mbedcrypto.c
++++ b/src/ecdh_mbedcrypto.c
+@@ -318,16 +318,13 @@ SSH_PACKET_CALLBACK(ssh_packet_server_ecdh_init){
+         goto out;
+     }
+ 
+-    rc = ssh_buffer_add_u8(session->out_buffer, SSH2_MSG_NEWKEYS);
+-    if (rc < 0) {
+-        rc = SSH_ERROR;
++    session->dh_handshake_state = DH_STATE_NEWKEYS_SENT;
++    /* Send the MSG_NEWKEYS */
++    rc = ssh_packet_send_newkeys(session);
++    if (rc == SSH_ERROR) {
+         goto out;
+     }
+ 
+-    session->dh_handshake_state = DH_STATE_NEWKEYS_SENT;
+-    rc = ssh_packet_send(session);
+-    SSH_LOG(SSH_LOG_DEBUG, "SSH_MSG_NEWKEYS sent");
+-
+ out:
+     mbedtls_ecp_group_free(&grp);
+     if (rc == SSH_ERROR) {
+diff --git a/src/kex.c b/src/kex.c
+index b9455d2d..3818297b 100644
+--- a/src/kex.c
++++ b/src/kex.c
+@@ -188,6 +188,9 @@
+ 
+ /* RFC 8308 */
+ #define KEX_EXTENSION_CLIENT "ext-info-c"
++/* Strict kex mitigation against CVE-2023-48795 */
++#define KEX_STRICT_CLIENT "kex-strict-c-v00@openssh.com"
++#define KEX_STRICT_SERVER "kex-strict-s-v00@openssh.com"
+ 
+ /* Allowed algorithms in FIPS mode */
+ #define FIPS_ALLOWED_CIPHERS "aes256-gcm@openssh.com,"\
+@@ -516,6 +519,27 @@ SSH_PACKET_CALLBACK(ssh_packet_kexinit)
+                     session->first_kex_follows_guess_wrong ? "wrong" : "right");
+     }
+ 
++    /*
++     * handle the "strict KEX" feature. If supported by peer, then set up the
++     * flag and verify packet sequence numbers.
++     */
++    if (server_kex) {
++        ok = ssh_match_group(crypto->client_kex.methods[SSH_KEX],
++                             KEX_STRICT_CLIENT);
++        if (ok) {
++            SSH_LOG(SSH_LOG_DEBUG, "Client supports strict kex, enabling.");
++            session->flags |= SSH_SESSION_FLAG_KEX_STRICT;
++        }
++    } else {
++        /* client kex */
++        ok = ssh_match_group(crypto->server_kex.methods[SSH_KEX],
++                             KEX_STRICT_SERVER);
++        if (ok) {
++            SSH_LOG(SSH_LOG_DEBUG, "Server supports strict kex, enabling.");
++            session->flags |= SSH_SESSION_FLAG_KEX_STRICT;
++        }
++    }
++
+     if (server_kex) {
+         /*
+          * If client sent a ext-info-c message in the kex list, it supports
+@@ -792,21 +816,21 @@ int ssh_set_client_kex(ssh_session session)
+         return SSH_OK;
+     }
+ 
+-    /* Here we append  ext-info-c  to the list of kex algorithms */
++    /* Here we append ext-info-c and kex-strict-c-v00@openssh.com to the list of kex algorithms */
+     kex = client->methods[SSH_KEX];
+     len = strlen(kex);
+-    if (len + strlen(KEX_EXTENSION_CLIENT) + 2 < len) {
++    /* Comma, comma, nul byte */
++    kex_len = len + 1 + strlen(KEX_EXTENSION_CLIENT) + 1 + strlen(KEX_STRICT_CLIENT ) + 1;
++    if (kex_len >= MAX_PACKET_LEN) {
+         /* Overflow */
+         return SSH_ERROR;
+     }
+-    kex_len = len + strlen(KEX_EXTENSION_CLIENT) + 2; /* comma, NULL */
+     kex_tmp = realloc(kex, kex_len);
+     if (kex_tmp == NULL) {
+-        free(kex);
+         ssh_set_error_oom(session);
+         return SSH_ERROR;
+     }
+-    snprintf(kex_tmp + len, kex_len - len, ",%s", KEX_EXTENSION_CLIENT);
++    snprintf(kex_tmp + len, kex_len - len, ",%s,%s", KEX_EXTENSION_CLIENT, KEX_STRICT_CLIENT);
+     client->methods[SSH_KEX] = kex_tmp;
+ 
+     return SSH_OK;
+diff --git a/src/packet.c b/src/packet.c
+index eb7eb42a..ea73f9ad 100644
+--- a/src/packet.c
++++ b/src/packet.c
+@@ -1314,6 +1314,19 @@ ssh_packet_socket_callback(const void *data, size_t receivedlen, void *user)
+             }
+ #endif /* WITH_ZLIB */
+             payloadsize = ssh_buffer_get_len(session->in_buffer);
++            if (session->recv_seq == UINT32_MAX) {
++                /* Overflowing sequence numbers is always fishy */
++                if (crypto == NULL) {
++                    /* don't allow sequence number overflow when unencrypted */
++                    ssh_set_error(session,
++                                  SSH_FATAL,
++                                  "Incoming sequence number overflow");
++                    goto error;
++                } else {
++                    SSH_LOG(SSH_LOG_WARNING,
++                            "Incoming sequence number overflow");
++                }
++            }
+             session->recv_seq++;
+             if (crypto != NULL) {
+                 struct ssh_cipher_struct *cipher = NULL;
+@@ -1354,6 +1379,9 @@ ssh_packet_socket_callback(const void *data, size_t receivedlen, void *user)
+                               session->in_packet.type);
+                 goto error;
+             case SSH_PACKET_UNKNOWN:
++                if (crypto == NULL) {
++                    session->flags |= SSH_SESSION_FLAG_KEX_TAINTED;
++                }
+                 ssh_packet_send_unimplemented(session, session->recv_seq - 1);
+                 break;
+             }
+@@ -1529,7 +1557,33 @@ void ssh_packet_process(ssh_session session, uint8_t type)
+             SSH_LOG(SSH_LOG_RARE, "Failed to send unimplemented: %s",
+                     ssh_get_error(session));
+         }
++        if (session->current_crypto == NULL) {
++            session->flags |= SSH_SESSION_FLAG_KEX_TAINTED;
++        }
++    }
++}
++
++/** @internal
++ * @brief sends a SSH_MSG_NEWKEYS when enabling the new negotiated ciphers
++ * @param session the SSH session
++ * @return SSH_ERROR on error, else SSH_OK
++ */
++int ssh_packet_send_newkeys(ssh_session session)
++{
++    int rc;
++
++    /* Send the MSG_NEWKEYS */
++    rc = ssh_buffer_add_u8(session->out_buffer, SSH2_MSG_NEWKEYS);
++    if (rc < 0) {
++        return rc;
+     }
++
++    rc = ssh_packet_send(session);
++    if (rc == SSH_ERROR) {
++        return rc;
++    }
++    SSH_LOG(SSH_LOG_DEBUG, "SSH_MSG_NEWKEYS sent");
++    return rc;
+ }
+ 
+ /** @internal
+@@ -1842,6 +1896,10 @@ int ssh_packet_send(ssh_session session)
+     if (rc == SSH_OK && type == SSH2_MSG_NEWKEYS) {
+         struct ssh_iterator *it;
+ 
++        if (session->flags & SSH_SESSION_FLAG_KEX_STRICT) {
++            /* reset packet sequence number when running in strict kex mode */
++            session->send_seq = 0;
++        }
+         for (it = ssh_list_get_iterator(session->out_queue);
+              it != NULL;
+              it = ssh_list_get_iterator(session->out_queue)) {
+diff --git a/src/packet_cb.c b/src/packet_cb.c
+index 0ecf8771..2f364c26 100644
+--- a/src/packet_cb.c
++++ b/src/packet_cb.c
+@@ -115,6 +115,18 @@ SSH_PACKET_CALLBACK(ssh_packet_newkeys){
+       goto error;
+   }
+ 
++  if (session->flags & SSH_SESSION_FLAG_KEX_STRICT) {
++      /* reset packet sequence number when running in strict kex mode */
++      session->recv_seq = 0;
++      /* Check that we aren't tainted */
++      if (session->flags & SSH_SESSION_FLAG_KEX_TAINTED) {
++          ssh_set_error(session,
++                        SSH_FATAL,
++                        "Received unexpected packets in strict KEX mode.");
++          goto error;
++      }
++  }
++
+   if(session->server){
+     /* server things are done in server.c */
+     session->dh_handshake_state=DH_STATE_FINISHED;
+-- 
+2.41.0
+
+
+From 0870c8db28be9eb457ee3d4f9a168959d9507efd Mon Sep 17 00:00:00 2001
+From: Aris Adamantiadis <aris@0xbadc0de.be>
+Date: Tue, 12 Dec 2023 23:30:26 +0100
+Subject: [PATCH 2/4] CVE-2023-48795: Server side mitigations
+
+Signed-off-by: Aris Adamantiadis <aris@0xbadc0de.be>
+Signed-off-by: Jakub Jelen <jjelen@redhat.com>
+Reviewed-by: Andreas Schneider <asn@cryptomilk.org>
+---
+ include/libssh/kex.h |  1 +
+ src/kex.c            | 46 ++++++++++++++++++++++++++++++++++----------
+ src/server.c         |  8 +++++++-
+ 3 files changed, 44 insertions(+), 11 deletions(-)
+
+diff --git a/include/libssh/kex.h b/include/libssh/kex.h
+index ede7fa8a..ba98fded 100644
+--- a/include/libssh/kex.h
++++ b/include/libssh/kex.h
+@@ -40,6 +40,7 @@ SSH_PACKET_CALLBACK(ssh_packet_kexinit);
+ int ssh_send_kex(ssh_session session);
+ void ssh_list_kex(struct ssh_kex_struct *kex);
+ int ssh_set_client_kex(ssh_session session);
++int ssh_kex_append_extensions(ssh_session session, struct ssh_kex_struct *pkex);
+ int ssh_kex_select_methods(ssh_session session);
+ int ssh_verify_existing_algo(enum ssh_kex_types_e algo, const char *name);
+ char *ssh_keep_known_algos(enum ssh_kex_types_e algo, const char *list);
+diff --git a/src/kex.c b/src/kex.c
+index 3818297b..9ad671db 100644
+--- a/src/kex.c
++++ b/src/kex.c
+@@ -763,11 +763,8 @@ int ssh_set_client_kex(ssh_session session)
+ {
+     struct ssh_kex_struct *client = &session->next_crypto->client_kex;
+     const char *wanted;
+-    char *kex = NULL;
+-    char *kex_tmp = NULL;
+     int ok;
+     int i;
+-    size_t kex_len, len;
+ 
+     /* Skip if already set, for example for the rekey or when we do the guessing
+      * it could have been already used to make some protocol decisions. */
+@@ -816,11 +813,33 @@ int ssh_set_client_kex(ssh_session session)
+         return SSH_OK;
+     }
+ 
+-    /* Here we append ext-info-c and kex-strict-c-v00@openssh.com to the list of kex algorithms */
+-    kex = client->methods[SSH_KEX];
++    ok = ssh_kex_append_extensions(session, client);
++    if (ok != SSH_OK){
++        return ok;
++    }
++
++    return SSH_OK;
++}
++
++int ssh_kex_append_extensions(ssh_session session, struct ssh_kex_struct *pkex)
++{
++    char *kex = NULL;
++    char *kex_tmp = NULL;
++    size_t kex_len, len;
++
++    /* Here we append ext-info-c and kex-strict-c-v00@openssh.com for client
++     * and kex-strict-s-v00@openssh.com for server to the list of kex algorithms
++     */
++    kex = pkex->methods[SSH_KEX];
+     len = strlen(kex);
+-    /* Comma, comma, nul byte */
+-    kex_len = len + 1 + strlen(KEX_EXTENSION_CLIENT) + 1 + strlen(KEX_STRICT_CLIENT ) + 1;
++    if (session->server) {
++        /* Comma, nul byte */
++        kex_len = len + 1 + strlen(KEX_STRICT_SERVER) + 1;
++    } else {
++        /* Comma, comma, nul byte */
++        kex_len = len + 1 + strlen(KEX_EXTENSION_CLIENT) + 1 +
++                  strlen(KEX_STRICT_CLIENT) + 1;
++    }
+     if (kex_len >= MAX_PACKET_LEN) {
+         /* Overflow */
+         return SSH_ERROR;
+@@ -830,9 +849,16 @@ int ssh_set_client_kex(ssh_session session)
+         ssh_set_error_oom(session);
+         return SSH_ERROR;
+     }
+-    snprintf(kex_tmp + len, kex_len - len, ",%s,%s", KEX_EXTENSION_CLIENT, KEX_STRICT_CLIENT);
+-    client->methods[SSH_KEX] = kex_tmp;
+-
++    if (session->server){
++        snprintf(kex_tmp + len, kex_len - len, ",%s", KEX_STRICT_SERVER);
++    } else {
++        snprintf(kex_tmp + len,
++                 kex_len - len,
++                 ",%s,%s",
++                 KEX_EXTENSION_CLIENT,
++                 KEX_STRICT_CLIENT);
++    }
++    pkex->methods[SSH_KEX] = kex_tmp;
+     return SSH_OK;
+ }
+ 
+diff --git a/src/server.c b/src/server.c
+index dc070a73..70b90899 100644
+--- a/src/server.c
++++ b/src/server.c
+@@ -195,7 +195,13 @@ int server_set_kex(ssh_session session)
+         }
+     }
+ 
+-    return 0;
++    /* Do not append the extensions during rekey */
++    if (session->flags & SSH_SESSION_FLAG_AUTHENTICATED) {
++        return SSH_OK;
++    }
++
++    rc = ssh_kex_append_extensions(session, server);
++    return rc;
+ }
+ 
+ int ssh_server_init_kex(ssh_session session) {
+-- 
+2.41.0
+
+
+From 5846e57538c750c5ce67df887d09fa99861c79c6 Mon Sep 17 00:00:00 2001
+From: Jakub Jelen <jjelen@redhat.com>
+Date: Thu, 14 Dec 2023 12:22:01 +0100
+Subject: [PATCH 3/4] CVE-2023-48795: Strip extensions from both kex lists for
+ matching
+
+Signed-off-by: Jakub Jelen <jjelen@redhat.com>
+Reviewed-by: Andreas Schneider <asn@cryptomilk.org>
+---
+ src/kex.c | 16 ++++++++++++----
+ 1 file changed, 12 insertions(+), 4 deletions(-)
+
+diff --git a/src/kex.c b/src/kex.c
+index 9ad671db..fbc70cf4 100644
+--- a/src/kex.c
++++ b/src/kex.c
+@@ -961,11 +961,19 @@ int ssh_kex_select_methods (ssh_session session)
+     enum ssh_key_exchange_e kex_type;
+     int i;
+ 
+-    /* Here we should drop the  ext-info-c  from the list so we avoid matching.
++    /* Here we should drop the extensions from the list so we avoid matching.
+      * it. We added it to the end, so we can just truncate the string here */
+-    ext_start = strstr(client->methods[SSH_KEX], ","KEX_EXTENSION_CLIENT);
+-    if (ext_start != NULL) {
+-        ext_start[0] = '\0';
++    if (session->client) {
++        ext_start = strstr(client->methods[SSH_KEX], "," KEX_EXTENSION_CLIENT);
++        if (ext_start != NULL) {
++            ext_start[0] = '\0';
++        }
++    }
++    if (session->server) {
++        ext_start = strstr(server->methods[SSH_KEX], "," KEX_STRICT_SERVER);
++        if (ext_start != NULL) {
++            ext_start[0] = '\0';
++        }
+     }
+ 
+     for (i = 0; i < SSH_KEX_METHODS; i++) {
+-- 
+2.41.0
+
+
+From 89df759200d31fc79fbbe213d8eda0d329eebf6d Mon Sep 17 00:00:00 2001
+From: Jakub Jelen <jjelen@redhat.com>
+Date: Thu, 14 Dec 2023 12:47:48 +0100
+Subject: [PATCH 4/4] CVE-2023-48795: tests: Adjust calculation to strict kex
+
+Signed-off-by: Jakub Jelen <jjelen@redhat.com>
+Reviewed-by: Andreas Schneider <asn@cryptomilk.org>
+---
+ tests/client/torture_rekey.c | 55 ++++++++++++++++++++----------------
+ 1 file changed, 31 insertions(+), 24 deletions(-)
+
+diff --git a/tests/client/torture_rekey.c b/tests/client/torture_rekey.c
+index ccd5ae2c..57e03e3f 100644
+--- a/tests/client/torture_rekey.c
++++ b/tests/client/torture_rekey.c
+@@ -148,6 +148,29 @@ static void torture_rekey_default(void **state)
+     ssh_disconnect(s->ssh.session);
+ }
+ 
++static void sanity_check_session(void **state)
++{
++    struct torture_state *s = *state;
++    struct ssh_crypto_struct *c = NULL;
++
++    c = s->ssh.session->current_crypto;
++    assert_non_null(c);
++    assert_int_equal(c->in_cipher->max_blocks,
++                     bytes / c->in_cipher->blocksize);
++    assert_int_equal(c->out_cipher->max_blocks,
++                     bytes / c->out_cipher->blocksize);
++    /* when strict kex is used, the newkeys reset the sequence number */
++    if ((s->ssh.session->flags & SSH_SESSION_FLAG_KEX_STRICT) != 0) {
++        assert_int_equal(c->out_cipher->packets, s->ssh.session->send_seq);
++        assert_int_equal(c->in_cipher->packets, s->ssh.session->recv_seq);
++    } else {
++        /* Otherwise we have less encrypted packets than transferred
++         * (first are not encrypted) */
++        assert_true(c->out_cipher->packets < s->ssh.session->send_seq);
++        assert_true(c->in_cipher->packets < s->ssh.session->recv_seq);
++    }
++}
++
+ /* We lower the rekey limits manually and check that the rekey
+  * really happens when sending data
+  */
+@@ -166,16 +189,10 @@ static void torture_rekey_send(void **state)
+     rc = ssh_connect(s->ssh.session);
+     assert_ssh_return_code(s->ssh.session, rc);
+ 
+-    /* The blocks limit is set correctly */
+-    c = s->ssh.session->current_crypto;
+-    assert_int_equal(c->in_cipher->max_blocks,
+-                     bytes / c->in_cipher->blocksize);
+-    assert_int_equal(c->out_cipher->max_blocks,
+-                     bytes / c->out_cipher->blocksize);
+-    /* We should have less encrypted packets than transfered (first are not encrypted) */
+-    assert_true(c->out_cipher->packets < s->ssh.session->send_seq);
+-    assert_true(c->in_cipher->packets < s->ssh.session->recv_seq);
++    sanity_check_session(state);
+     /* Copy the initial secret hash = session_id so we know we changed keys later */
++    c = s->ssh.session->current_crypto;
++    assert_non_null(c);
+     secret_hash = malloc(c->digest_len);
+     assert_non_null(secret_hash);
+     memcpy(secret_hash, c->secret_hash, c->digest_len);
+@@ -468,15 +480,10 @@ static void torture_rekey_different_kex(void **state)
+     assert_ssh_return_code(s->ssh.session, rc);
+ 
+     /* The blocks limit is set correctly */
+-    c = s->ssh.session->current_crypto;
+-    assert_int_equal(c->in_cipher->max_blocks,
+-                     bytes / c->in_cipher->blocksize);
+-    assert_int_equal(c->out_cipher->max_blocks,
+-                     bytes / c->out_cipher->blocksize);
+-    /* We should have less encrypted packets than transfered (first are not encrypted) */
+-    assert_true(c->out_cipher->packets < s->ssh.session->send_seq);
+-    assert_true(c->in_cipher->packets < s->ssh.session->recv_seq);
++    sanity_check_session(state);
+     /* Copy the initial secret hash = session_id so we know we changed keys later */
++    c = s->ssh.session->current_crypto;
++    assert_non_null(c);
+     secret_hash = malloc(c->digest_len);
+     assert_non_null(secret_hash);
+     memcpy(secret_hash, c->secret_hash, c->digest_len);
+-- 
+2.41.0
+
+diff -up libssh-0.10.4/src/packet.c.CVE-2023-48795.patch libssh-0.10.4/src/packet.c
+--- libssh-0.10.4/src/packet.c.CVE-2023-48795.patch	2024-01-09 05:46:53.064383034 +0100
++++ libssh-0.10.4/src/packet.c	2024-01-09 05:48:28.360340184 +0100
+@@ -1345,6 +1345,19 @@ size_t ssh_packet_socket_callback(const
+                     "packet: read type %hhd [len=%d,padding=%hhd,comp=%d,payload=%d]",
+                     session->in_packet.type, packet_len, padding, compsize, payloadsize);
+ 
++            if (crypto == NULL) {
++                /* In strict kex, only a few packets are allowed. Taint the session
++                 * if we received packets that are normally allowed but to be
++                 * refused if we are in strict kex when KEX is over.
++                 */
++                uint8_t type = session->in_packet.type;
++
++                if (type != SSH2_MSG_KEXINIT && type != SSH2_MSG_NEWKEYS &&
++                    (type < SSH2_MSG_KEXDH_INIT ||
++                     type > SSH2_MSG_KEX_DH_GEX_REQUEST)) {
++                    session->flags |= SSH_SESSION_FLAG_KEX_TAINTED;
++                }
++            }
+             /* Check if the packet is expected */
+             filter_result = ssh_packet_incoming_filter(session);
+ 
+diff -up libssh-0.10.4/tests/client/torture_rekey.c.CVE-2023-48795.patch libssh-0.10.4/tests/client/torture_rekey.c
+--- libssh-0.10.4/tests/client/torture_rekey.c.CVE-2023-48795.patch	2024-01-09 18:48:16.684366049 +0100
++++ libssh-0.10.4/tests/client/torture_rekey.c	2024-01-09 18:50:49.135897268 +0100
+@@ -290,14 +290,10 @@ static void torture_rekey_recv(void **st
+     mode_t mask;
+     int rc;
+ 
+-    /* The blocks limit is set correctly */
+-    c = s->ssh.session->current_crypto;
+-    assert_int_equal(c->in_cipher->max_blocks, bytes / c->in_cipher->blocksize);
+-    assert_int_equal(c->out_cipher->max_blocks, bytes / c->out_cipher->blocksize);
+-    /* We should have less encrypted packets than transfered (first are not encrypted) */
+-    assert_true(c->out_cipher->packets < s->ssh.session->send_seq);
+-    assert_true(c->in_cipher->packets < s->ssh.session->recv_seq);
++    sanity_check_session(state);
+     /* Copy the initial secret hash = session_id so we know we changed keys later */
++    c = s->ssh.session->current_crypto;
++    assert_non_null(c);
+     secret_hash = malloc(c->digest_len);
+     assert_non_null(secret_hash);
+     memcpy(secret_hash, c->secret_hash, c->digest_len);

SOURCES/auth_bypass.patch

@@ -0,0 +1,82 @@
+diff --color -ru ../libssh-0.10.4/src/pki_crypto.c ./src/pki_crypto.c
+--- ../libssh-0.10.4/src/pki_crypto.c	2023-04-27 13:24:03.105744519 +0200
++++ ./src/pki_crypto.c	2023-04-27 13:30:24.016756496 +0200
+@@ -3186,8 +3186,12 @@
+     unsigned char *raw_sig_data = NULL;
+     unsigned int raw_sig_len;
+ 
++    /* Function return code
++     * Do not change this variable throughout the function until the signature
++     * is successfully verified!
++     */
+     int rc = SSH_ERROR;
+-    int evp_rc;
++    int ok;
+ 
+     if (pubkey == NULL || ssh_key_is_private(pubkey) || input == NULL ||
+         signature == NULL || (signature->raw_sig == NULL
+@@ -3202,8 +3206,8 @@
+     }
+ 
+     /* Check if public key and hash type are compatible */
+-    rc = pki_key_check_hash_compatible(pubkey, signature->hash_type);
+-    if (rc != SSH_OK) {
++    ok = pki_key_check_hash_compatible(pubkey, signature->hash_type);
++    if (ok != SSH_OK) {
+         return SSH_ERROR;
+     }
+ 
+@@ -3248,8 +3252,8 @@
+     }
+ 
+     /* Verify the signature */
+-    evp_rc = EVP_DigestVerifyInit(ctx, NULL, md, NULL, pkey);
+-    if (evp_rc != 1){
++    ok = EVP_DigestVerifyInit(ctx, NULL, md, NULL, pkey);
++    if (ok != 1){
+         SSH_LOG(SSH_LOG_TRACE,
+                 "EVP_DigestVerifyInit() failed: %s",
+                 ERR_error_string(ERR_get_error(), NULL));
+@@ -3257,32 +3261,30 @@
+     }
+ 
+ #ifdef HAVE_OPENSSL_EVP_DIGESTVERIFY
+-    evp_rc = EVP_DigestVerify(ctx, raw_sig_data, raw_sig_len, input, input_len);
++    ok = EVP_DigestVerify(ctx, raw_sig_data, raw_sig_len, input, input_len);
+ #else
+-    evp_rc = EVP_DigestVerifyUpdate(ctx, input, input_len);
+-    if (evp_rc != 1) {
++    ok = EVP_DigestVerifyUpdate(ctx, input, input_len);
++    if (ok != 1) {
+         SSH_LOG(SSH_LOG_TRACE,
+                 "EVP_DigestVerifyUpdate() failed: %s",
+                 ERR_error_string(ERR_get_error(), NULL));
+         goto out;
+     }
+ 
+-    evp_rc = EVP_DigestVerifyFinal(ctx, raw_sig_data, raw_sig_len);
++    ok = EVP_DigestVerifyFinal(ctx, raw_sig_data, raw_sig_len);
+ #endif
+-    if (evp_rc == 1) {
+-        SSH_LOG(SSH_LOG_TRACE, "Signature valid");
+-        rc = SSH_OK;
+-    } else {
++    if (ok != 1) {
+         SSH_LOG(SSH_LOG_TRACE,
+                 "Signature invalid: %s",
+                 ERR_error_string(ERR_get_error(), NULL));
+-        rc = SSH_ERROR;
++        goto out;
+     }
+ 
++    SSH_LOG(SSH_LOG_TRACE, "Signature valid");
++    rc = SSH_OK;
++
+ out:
+-    if (ctx != NULL) {
+-        EVP_MD_CTX_free(ctx);
+-    }
++    EVP_MD_CTX_free(ctx);
+     EVP_PKEY_free(pkey);
+     return rc;
+ }

SOURCES/coverity_scan.patch

@@ -0,0 +1,23 @@
+diff --git a/src/dh_crypto.c b/src/dh_crypto.c
+index a847c6a2..1eb94307 100644
+--- a/src/dh_crypto.c
++++ b/src/dh_crypto.c
+@@ -341,8 +341,16 @@ int ssh_dh_set_parameters(struct dh_ctx *ctx,
+             goto done;
+         }
+ 
+-        OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_FFC_P, modulus);
+-        OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_FFC_G, generator);
++        rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_FFC_P, modulus);
++        if (rc != 1) {
++            rc = SSH_ERROR;
++            goto done;
++        }
++        rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_FFC_G, generator);
++        if (rc != 1) {
++            rc = SSH_ERROR;
++            goto done;
++        }
+         params = OSSL_PARAM_BLD_to_param(param_bld);
+         if (params == NULL) {
+             OSSL_PARAM_BLD_free(param_bld);

SOURCES/covscan23.patch

@@ -0,0 +1,228 @@
+diff --color -ru ../libssh-0.10.4/src/buffer.c ./src/buffer.c
+--- ../libssh-0.10.4/src/buffer.c	2023-05-03 12:22:40.304114511 +0200
++++ ./src/buffer.c	2023-05-03 12:24:11.578110236 +0200
+@@ -747,7 +747,8 @@
+  */
+ int ssh_buffer_validate_length(struct ssh_buffer_struct *buffer, size_t len)
+ {
+-    if (buffer->pos + len < len || buffer->pos + len > buffer->used) {
++    if (buffer == NULL || buffer->pos + len < len ||
++        buffer->pos + len > buffer->used) {
+         return SSH_ERROR;
+     }
+ 
+diff --color -ru ../libssh-0.10.4/src/gssapi.c ./src/gssapi.c
+--- ../libssh-0.10.4/src/gssapi.c	2023-05-03 12:22:40.356115078 +0200
++++ ./src/gssapi.c	2023-05-03 12:24:11.566110105 +0200
+@@ -444,11 +444,18 @@
+         hexa = ssh_get_hexa(output_token.value, output_token.length);
+         SSH_LOG(SSH_LOG_PACKET, "GSSAPI: sending token %s",hexa);
+         SAFE_FREE(hexa);
+-        ssh_buffer_pack(session->out_buffer,
+-                        "bdP",
+-                        SSH2_MSG_USERAUTH_GSSAPI_TOKEN,
+-                        output_token.length,
+-                        (size_t)output_token.length, output_token.value);
++        rc = ssh_buffer_pack(session->out_buffer,
++                             "bdP",
++                             SSH2_MSG_USERAUTH_GSSAPI_TOKEN,
++                             output_token.length,
++                             (size_t)output_token.length, output_token.value);
++        if (rc != SSH_OK) {
++            ssh_set_error_oom(session);
++            ssh_auth_reply_default(session, 0);
++            ssh_gssapi_free(session);
++            session->gssapi = NULL;
++            return SSH_PACKET_USED;
++        }
+         ssh_packet_send(session);
+     }
+ 
+@@ -857,6 +864,7 @@
+ }
+ 
+ SSH_PACKET_CALLBACK(ssh_packet_userauth_gssapi_response){
++    int rc;
+     ssh_string oid_s;
+     gss_uint32 maj_stat, min_stat;
+     gss_buffer_desc input_token = GSS_C_EMPTY_BUFFER;
+@@ -908,11 +916,15 @@
+         hexa = ssh_get_hexa(output_token.value, output_token.length);
+         SSH_LOG(SSH_LOG_PACKET, "GSSAPI: sending token %s", hexa);
+         SAFE_FREE(hexa);
+-        ssh_buffer_pack(session->out_buffer,
+-                        "bdP",
+-                        SSH2_MSG_USERAUTH_GSSAPI_TOKEN,
+-                        output_token.length,
+-                        (size_t)output_token.length, output_token.value);
++        rc = ssh_buffer_pack(session->out_buffer,
++                             "bdP",
++                             SSH2_MSG_USERAUTH_GSSAPI_TOKEN,
++                             output_token.length,
++                             (size_t)output_token.length, output_token.value);
++        if (rc != SSH_OK) {
++            ssh_set_error_oom(session);
++            goto error;
++        }
+         ssh_packet_send(session);
+         session->auth.state = SSH_AUTH_STATE_GSSAPI_TOKEN;
+     }
+@@ -975,6 +987,7 @@
+ }
+ 
+ SSH_PACKET_CALLBACK(ssh_packet_userauth_gssapi_token_client){
++    int rc;
+     ssh_string token;
+     char *hexa;
+     OM_uint32 maj_stat, min_stat;
+@@ -1027,11 +1040,15 @@
+         hexa = ssh_get_hexa(output_token.value, output_token.length);
+         SSH_LOG(SSH_LOG_PACKET, "GSSAPI: sending token %s",hexa);
+         SAFE_FREE(hexa);
+-        ssh_buffer_pack(session->out_buffer,
+-                        "bdP",
+-                        SSH2_MSG_USERAUTH_GSSAPI_TOKEN,
+-                        output_token.length,
+-                        (size_t)output_token.length, output_token.value);
++        rc = ssh_buffer_pack(session->out_buffer,
++                             "bdP",
++                             SSH2_MSG_USERAUTH_GSSAPI_TOKEN,
++                             output_token.length,
++                             (size_t)output_token.length, output_token.value);
++        if (rc != SSH_OK) {
++            ssh_set_error_oom(session);
++            goto error;
++        }
+         ssh_packet_send(session);
+     }
+ 
+diff --color -ru ../libssh-0.10.4/src/options.c ./src/options.c
+--- ../libssh-0.10.4/src/options.c	2023-05-03 12:22:40.342114926 +0200
++++ ./src/options.c	2023-05-03 12:24:11.582110280 +0200
+@@ -614,7 +614,9 @@
+                 }
+                 i = strtol(q, &p, 10);
+                 if (q == p) {
++                    SSH_LOG(SSH_LOG_DEBUG, "No port number was parsed");
+                     SAFE_FREE(q);
++                    return -1;
+                 }
+                 SAFE_FREE(q);
+                 if (i <= 0) {
+@@ -816,7 +818,9 @@
+                 }
+                 i = strtol(q, &p, 10);
+                 if (q == p) {
++                    SSH_LOG(SSH_LOG_DEBUG, "No log verbositiy was parsed");
+                     SAFE_FREE(q);
++                    return -1;
+                 }
+                 SAFE_FREE(q);
+                 if (i < 0) {
+@@ -2035,7 +2039,9 @@
+         }
+         i = strtol(q, &p, 10);
+         if (q == p) {
+-          SAFE_FREE(q);
++            SSH_LOG(SSH_LOG_DEBUG, "No bind port was parsed");
++            SAFE_FREE(q);
++            return -1;
+         }
+         SAFE_FREE(q);
+ 
+@@ -2062,7 +2068,9 @@
+         }
+         i = strtol(q, &p, 10);
+         if (q == p) {
+-          SAFE_FREE(q);
++            SSH_LOG(SSH_LOG_DEBUG, "No log verbositiy was parsed");
++            SAFE_FREE(q);
++            return -1;
+         }
+         SAFE_FREE(q);
+ 
+diff --color -ru ../libssh-0.10.4/src/pki_container_openssh.c ./src/pki_container_openssh.c
+--- ../libssh-0.10.4/src/pki_container_openssh.c	2023-05-03 12:22:40.314114620 +0200
++++ ./src/pki_container_openssh.c	2023-05-03 12:24:11.566110105 +0200
+@@ -630,7 +630,11 @@
+             goto error;
+         }
+ 
+-        ssh_buffer_pack(kdf_buf, "Sd", salt, rounds);
++        rc = ssh_buffer_pack(kdf_buf, "Sd", salt, rounds);
++        if (rc != SSH_OK) {
++            SSH_BUFFER_FREE(kdf_buf);
++            goto error;
++        }
+         kdf_options = ssh_string_new(ssh_buffer_get_len(kdf_buf));
+         if (kdf_options == NULL){
+             SSH_BUFFER_FREE(kdf_buf);
+diff --color -ru ../libssh-0.10.4/tests/unittests/torture_options.c ./tests/unittests/torture_options.c
+--- ../libssh-0.10.4/tests/unittests/torture_options.c	2023-05-03 12:22:40.343114937 +0200
++++ ./tests/unittests/torture_options.c	2023-05-03 12:24:11.587110335 +0200
+@@ -319,6 +319,7 @@
+ 
+     rc = ssh_options_set(session, SSH_OPTIONS_PORT_STR, "five");
+     assert_true(rc == -1);
++    assert_int_not_equal(session->opts.port, 0);
+ 
+     rc = ssh_options_set(session, SSH_OPTIONS_PORT, NULL);
+     assert_true(rc == -1);
+@@ -1496,6 +1497,26 @@
+     ssh_list_free(awaited_list);
+ }
+ 
++static void torture_options_set_verbosity (void **state)
++{
++    ssh_session session = *state;
++    int rc, new_level;
++
++    rc = ssh_options_set(session,
++                         SSH_OPTIONS_LOG_VERBOSITY_STR,
++                         "3");
++    assert_int_equal(rc, SSH_OK);
++    new_level = ssh_get_log_level();
++    assert_int_equal(new_level, SSH_LOG_PACKET);
++
++    rc = ssh_options_set(session,
++                         SSH_OPTIONS_LOG_VERBOSITY_STR,
++                         "datsun");
++    assert_int_equal(rc, -1);
++    new_level = ssh_get_log_level();
++    assert_int_not_equal(new_level, 0);
++}
++
+ #ifdef WITH_SERVER
+ const char template[] = "temp_dir_XXXXXX";
+ 
+@@ -1750,6 +1771,10 @@
+     rc = ssh_bind_options_set(bind, SSH_BIND_OPTIONS_BINDPORT_STR, "23");
+     assert_int_equal(rc, 0);
+     assert_int_equal(bind->bindport, 23);
++
++    rc = ssh_bind_options_set(bind, SSH_BIND_OPTIONS_BINDPORT_STR, "twentythree");
++    assert_int_equal(rc, -1);
++    assert_int_not_equal(bind->bindport, 0);
+ }
+ 
+ static void torture_bind_options_log_verbosity(void **state)
+@@ -1799,6 +1824,11 @@
+     new_level = ssh_get_log_level();
+     assert_int_equal(new_level, SSH_LOG_PACKET);
+ 
++    rc = ssh_bind_options_set(bind, SSH_BIND_OPTIONS_LOG_VERBOSITY_STR, "verbosity");
++    assert_int_equal(rc, -1);
++    new_level = ssh_get_log_level();
++    assert_int_not_equal(new_level, 0);
++
+     rc = ssh_set_log_level(previous_level);
+     assert_int_equal(rc, SSH_OK);
+ }
+@@ -2297,6 +2327,7 @@
+         cmocka_unit_test_setup_teardown(torture_options_caret_sign,
+                                         setup, teardown),
+         cmocka_unit_test_setup_teardown(torture_options_apply, setup, teardown),
++        cmocka_unit_test_setup_teardown(torture_options_set_verbosity, setup, teardown),
+     };
+ 
+ #ifdef WITH_SERVER

SOURCES/covscan23_1.patch

@@ -0,0 +1,57 @@
+File ../libssh-0.10.4/.git is a regular file while file ./.git is a directory
+diff --color -ru ../libssh-0.10.4/src/sftp.c ./src/sftp.c
+--- ../libssh-0.10.4/src/sftp.c	2023-05-22 12:45:48.383509085 +0200
++++ ./src/sftp.c	2023-05-22 12:54:31.004037650 +0200
+@@ -1755,6 +1755,10 @@
+ int sftp_close(sftp_file file){
+   int err = SSH_NO_ERROR;
+ 
++  if (file == NULL) {
++      return err;
++  }
++
+   SAFE_FREE(file->name);
+   if (file->handle){
+     err = sftp_handle_close(file->sftp,file->handle);
+@@ -1917,7 +1921,7 @@
+ 
+ /* Read from a file using an opened sftp file handle. */
+ ssize_t sftp_read(sftp_file handle, void *buf, size_t count) {
+-  sftp_session sftp = handle->sftp;
++  sftp_session sftp;
+   sftp_message msg = NULL;
+   sftp_status_message status;
+   ssh_string datastring;
+@@ -1926,6 +1930,11 @@
+   uint32_t id;
+   int rc;
+ 
++  if (handle == NULL) {
++      return -1;
++  }
++  sftp = handle->sftp;
++
+   if (handle->eof) {
+     return 0;
+   }
+@@ -2147,7 +2156,7 @@
+ }
+ 
+ ssize_t sftp_write(sftp_file file, const void *buf, size_t count) {
+-  sftp_session sftp = file->sftp;
++  sftp_session sftp;
+   sftp_message msg = NULL;
+   sftp_status_message status;
+   ssh_buffer buffer;
+@@ -2156,6 +2165,11 @@
+   size_t packetlen;
+   int rc;
+ 
++  if (file == NULL) {
++      return -1;
++  }
++  sftp = file->sftp;
++
+   buffer = ssh_buffer_new();
+   if (buffer == NULL) {
+     ssh_set_error_oom(sftp->session);

SOURCES/enable_sk_keys_by_config.patch

@@ -0,0 +1,105 @@
+diff --git a/src/kex.c b/src/kex.c
+index 1155b9c7..528cb182 100644
+--- a/src/kex.c
++++ b/src/kex.c
+@@ -101,12 +101,19 @@
+ 
+ #ifdef HAVE_ECDH
+ #define ECDH "ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521,"
+-#define EC_HOSTKEYS "ecdsa-sha2-nistp521,ecdsa-sha2-nistp384,ecdsa-sha2-nistp256,"
+-#define EC_PUBLIC_KEY_ALGORITHMS "ecdsa-sha2-nistp521-cert-v01@openssh.com," \
++#define EC_HOSTKEYS "ecdsa-sha2-nistp521," \
++                    "ecdsa-sha2-nistp384," \
++                    "ecdsa-sha2-nistp256,"
++#define EC_SK_HOSTKEYS "sk-ecdsa-sha2-nistp256@openssh.com,"
++#define EC_FIPS_PUBLIC_KEY_ALGOS "ecdsa-sha2-nistp521-cert-v01@openssh.com," \
+                                  "ecdsa-sha2-nistp384-cert-v01@openssh.com," \
+                                  "ecdsa-sha2-nistp256-cert-v01@openssh.com,"
++#define EC_PUBLIC_KEY_ALGORITHMS EC_FIPS_PUBLIC_KEY_ALGOS \
++                                 "sk-ecdsa-sha2-nistp256-cert-v01@openssh.com,"
+ #else
+ #define EC_HOSTKEYS ""
++#define EC_SK_HOSTKEYS ""
++#define EC_FIPS_PUBLIC_KEY_ALGOS ""
+ #define EC_PUBLIC_KEY_ALGORITHMS ""
+ #define ECDH ""
+ #endif /* HAVE_ECDH */
+@@ -127,16 +134,21 @@
+ 
+ #define HOSTKEYS "ssh-ed25519," \
+                  EC_HOSTKEYS \
++                 "sk-ssh-ed25519@openssh.com," \
++                 EC_SK_HOSTKEYS \
+                  "rsa-sha2-512," \
+                  "rsa-sha2-256," \
+                  "ssh-rsa" \
+                  DSA_HOSTKEYS
+ #define DEFAULT_HOSTKEYS "ssh-ed25519," \
+                          EC_HOSTKEYS \
++                         "sk-ssh-ed25519@openssh.com," \
++                         EC_SK_HOSTKEYS \
+                          "rsa-sha2-512," \
+                          "rsa-sha2-256"
+ 
+ #define PUBLIC_KEY_ALGORITHMS "ssh-ed25519-cert-v01@openssh.com," \
++                              "sk-ssh-ed25519-cert-v01@openssh.com," \
+                               EC_PUBLIC_KEY_ALGORITHMS \
+                               "rsa-sha2-512-cert-v01@openssh.com," \
+                               "rsa-sha2-256-cert-v01@openssh.com," \
+@@ -186,7 +198,7 @@
+                               "rsa-sha2-512," \
+                               "rsa-sha2-256"
+ 
+-#define FIPS_ALLOWED_PUBLIC_KEY_ALGORITHMS EC_PUBLIC_KEY_ALGORITHMS \
++#define FIPS_ALLOWED_PUBLIC_KEY_ALGORITHMS EC_FIPS_PUBLIC_KEY_ALGOS \
+                                            "rsa-sha2-512-cert-v01@openssh.com," \
+                                            "rsa-sha2-256-cert-v01@openssh.com," \
+                                            FIPS_ALLOWED_HOSTKEYS
+diff --git a/src/knownhosts.c b/src/knownhosts.c
+index 1f52dedc..94618fe2 100644
+--- a/src/knownhosts.c
++++ b/src/knownhosts.c
+@@ -480,6 +480,8 @@ static const char *ssh_known_host_sigs_from_hostkey_type(enum ssh_keytypes_e typ
+         return "rsa-sha2-512,rsa-sha2-256,ssh-rsa";
+     case SSH_KEYTYPE_ED25519:
+         return "ssh-ed25519";
++    case SSH_KEYTYPE_SK_ED25519:
++        return "sk-ssh-ed25519@openssh.com";
+ #ifdef HAVE_DSA
+     case SSH_KEYTYPE_DSS:
+         return "ssh-dss";
+@@ -494,6 +496,8 @@ static const char *ssh_known_host_sigs_from_hostkey_type(enum ssh_keytypes_e typ
+         return "ecdsa-sha2-nistp384";
+     case SSH_KEYTYPE_ECDSA_P521:
+         return "ecdsa-sha2-nistp521";
++    case SSH_KEYTYPE_SK_ECDSA:
++        return "sk-ecdsa-sha2-nistp256@openssh.com";
+ #else
+     case SSH_KEYTYPE_ECDSA_P256:
+     case SSH_KEYTYPE_ECDSA_P384:
+diff --git a/tests/unittests/torture_knownhosts_parsing.c b/tests/unittests/torture_knownhosts_parsing.c
+index fffa8296..7fd21f05 100644
+--- a/tests/unittests/torture_knownhosts_parsing.c
++++ b/tests/unittests/torture_knownhosts_parsing.c
+@@ -634,7 +634,9 @@ static void torture_knownhosts_algorithms(void **state)
+     bool process_config = false;
+     const char *expect = "ssh-ed25519,rsa-sha2-512,rsa-sha2-256,"
+                          "ecdsa-sha2-nistp521,ecdsa-sha2-nistp384,"
+-                         "ecdsa-sha2-nistp256";
++                         "ecdsa-sha2-nistp256,"
++                         "sk-ssh-ed25519@openssh.com,"
++                         "sk-ecdsa-sha2-nistp256@openssh.com";
+     const char *expect_fips = "rsa-sha2-512,rsa-sha2-256,ecdsa-sha2-nistp521,"
+                               "ecdsa-sha2-nistp384,ecdsa-sha2-nistp256";
+ 
+@@ -669,7 +671,9 @@ static void torture_knownhosts_algorithms_global(void **state)
+     bool process_config = false;
+     const char *expect = "ssh-ed25519,rsa-sha2-512,rsa-sha2-256,"
+                          "ecdsa-sha2-nistp521,ecdsa-sha2-nistp384,"
+-                         "ecdsa-sha2-nistp256";
++                         "ecdsa-sha2-nistp256,"
++                         "sk-ssh-ed25519@openssh.com,"
++                         "sk-ecdsa-sha2-nistp256@openssh.com";
+     const char *expect_fips = "rsa-sha2-512,rsa-sha2-256,ecdsa-sha2-nistp521,"
+                               "ecdsa-sha2-nistp384,ecdsa-sha2-nistp256";
+ 

SOURCES/libssh-0.10.4.tar.xz.asc

@@ -0,0 +1,16 @@
+-----BEGIN PGP SIGNATURE-----
+
+iQIzBAABCgAdFiEEjf9T4Y8qvI2PPJIjfuD8TcwBTj0FAmMYnSEACgkQfuD8TcwB
+Tj2qGBAAn/40MU/7PcyCRK9U+MhLo28peRpTF+i1/k0V5czVLiFubeFofsa6sjy8
+C6VyQsz0NYiTf6wXLlq9jO1p31LWQ13Z3K0d7Lg2eyftsVrGM1Ue9dTLlJrZ570d
+JjcBR/J3dpO9w5fz4HawWE8GIBBstZQnZYdoT75+tIeSMJ/tnovKfE1RGYc4kRJs
+quC7tyej7Y+t86U8psFSy2iUCajS82b+ddZEhuxwamel+RBRJZsmi5B2OvhkEaOj
+mhJOIkx3UD9XAjxeooVcTlzAaJ5JFZ7Im97o+DRbQYvJYe4ZqDo17lrzBh6wruLC
+vBo+/lwh9FbCqxbDpFfqwpf8qYsWu3m0Qlu5f+BZ/9WvjFCVoRmScNHJo42tu18r
+xcX2Txis8oWysgqhvIgTFRnLq010ErL8iE9WeZwrNJgcTnf+AQLolKQiVAHumMvk
+Djv0No+ZTBG03Hsb0tbvA8kVtxI0ZZtzPcRkRqmUwiLCtcO9oo1hInhu+D1sPZwI
+Q1xK6hI6LKsF80yPKGexZxlgV/vZYhIKtD0SIoZCpx7MSBxXqHYZARtTFUAXBSqF
+tIn800/pPhGuY1/x3ho4BeWCGj1eWG5zy7dr0q/d/OiqBj3OiUfxtTl4drqrYhca
+goNhzNTs0Ps+iYbVQlk4nEAjg54M8ru1jfcuNRgrhTqCI8yiESk=
+=AG91
+-----END PGP SIGNATURE-----

SOURCES/libssh-0.11.1-fix-provider-loading.patch

@@ -1,54 +0,0 @@
-diff -up libssh-0.11.1/tests/client/torture_auth_pkcs11.c.tmp libssh-0.11.1/tests/client/torture_auth_pkcs11.c
---- libssh-0.11.1/tests/client/torture_auth_pkcs11.c.tmp	2024-10-25 11:58:50.341126170 +0200
-+++ libssh-0.11.1/tests/client/torture_auth_pkcs11.c	2024-10-25 12:11:01.766453259 +0200
-@@ -240,6 +240,14 @@ int torture_run_tests(void) {
-                                         session_teardown),
-     };
- 
-+    /* Do not use system openssl.cnf for the pkcs11 uri tests.
-+     * It can load a pkcs11 provider too early before we will set up environment
-+     * variables that are needed for the pkcs11 provider to access correct
-+     * tokens, causing unexpected failures.
-+     * Make sure this comes before ssh_init(), which initializes OpenSSL!
-+     */
-+    setenv("OPENSSL_CONF", "/dev/null", 1);
-+
-     ssh_init();
-     torture_filter_tests(tests);
-     rc = cmocka_run_group_tests(tests, sshd_setup, sshd_teardown);
-diff -up libssh-0.11.1/tests/unittests/torture_pki_ecdsa_uri.c.tmp libssh-0.11.1/tests/unittests/torture_pki_ecdsa_uri.c
---- libssh-0.11.1/tests/unittests/torture_pki_ecdsa_uri.c.tmp	2024-10-25 11:59:22.964367137 +0200
-+++ libssh-0.11.1/tests/unittests/torture_pki_ecdsa_uri.c	2024-10-25 12:12:51.473625481 +0200
-@@ -563,6 +563,14 @@ int torture_run_tests(void) {
-     ssh_session session = ssh_new();
-     int verbosity = SSH_LOG_FUNCTIONS;
- 
-+    /* Do not use system openssl.cnf for the pkcs11 uri tests.
-+     * It can load a pkcs11 provider too early before we will set up environment
-+     * variables that are needed for the pkcs11 provider to access correct
-+     * tokens, causing unexpected failures.
-+     * Make sure this comes before ssh_init(), which initializes OpenSSL!
-+     */
-+    setenv("OPENSSL_CONF", "/dev/null", 1);
-+
-     ssh_init();
-     ssh_options_set(session, SSH_OPTIONS_LOG_VERBOSITY, &verbosity);
- 
-diff -up libssh-0.11.1/tests/unittests/torture_pki_rsa_uri.c.tmp libssh-0.11.1/tests/unittests/torture_pki_rsa_uri.c
---- libssh-0.11.1/tests/unittests/torture_pki_rsa_uri.c.tmp	2024-10-25 11:59:49.241336178 +0200
-+++ libssh-0.11.1/tests/unittests/torture_pki_rsa_uri.c	2024-10-25 12:12:10.985614709 +0200
-@@ -285,6 +285,14 @@ torture_run_tests(void)
-     ssh_session session = ssh_new();
-     int verbosity = SSH_LOG_FUNCTIONS;
- 
-+    /* Do not use system openssl.cnf for the pkcs11 uri tests.
-+     * It can load a pkcs11 provider too early before we will set up environment
-+     * variables that are needed for the pkcs11 provider to access correct
-+     * tokens, causing unexpected failures.
-+     * Make sure this comes before ssh_init(), which initializes OpenSSL!
-+     */
-+    setenv("OPENSSL_CONF", "/dev/null", 1);
-+
-     ssh_options_set(session, SSH_OPTIONS_LOG_VERBOSITY, &verbosity);
-     ssh_init();
- 

SOURCES/libssh-0.11.1.tar.xz.asc

@@ -1,16 +0,0 @@
------BEGIN PGP SIGNATURE-----
-
-iQIzBAABCAAdFiEEiKIo2JsHwsd9DHgJA9XfjP3T6OcFAmbRl74ACgkQA9XfjP3T
-6OdnSw/+IrXAbSSpjVNG5Wjz3WQjqXkWInCT+qNhcS5w+qasGW5i6mktoNJkg2Fd
-P4iRCeJEuZbOHZLWXdUaDKjmlOUIda2xA8U01uw2VrleEu05JV/s5tS1MpVOPfDi
-8+CTxPesFQ9uX9q+OojTr4QXqBDqv15sldwRVTKegNpLkk3xHUUaMjwikWKKxXG+
-ypD4UCJWKVVhen9HPRSUOtruliZFPxQSLYvj4XKJxpr/QVaORS0EsTpdYP0h1+18
-6epynp4e1/9GRTmrKa8/JcCd/4c2UnHBFpw0DU1YirLK+54/qD76o63MTbo7mKru
-cgfypfA/sdeklGTZYLrCyizcrSc2poaTznczUZC6gi3FxivLoldFyDgXeSQWEieB
-QTGgnaLkB2Y2XuBl9F9MatqFC35TBuUUwHBoEa31acQhmotui5tF4oq/JxRtZi8v
-OyrTYc/xfmDh4SbWuEVqr6B2SZjhxrIvEGEe4adJQ/tVN2wweoNgTHt8XjBb1amB
-M9RPeXG5Uon+gIXDVzjgx+DZ85FweCEngv+OdjHPIBWsJUEc722L/gypIFnBfaPV
-JgM84wxQz2J8xyk2zEANog9M8ae5jG9TVJORO8to+gbRlKB2ZRDdDne0cgRUSWaj
-0IKsnehsxjF2OqChjRqRMBhfVAA0hrYU1ngxwCcdAcdlbfgs5L0=
-=P/pw
------END PGP SIGNATURE-----

SOURCES/libssh.keyring

@@ -1,52 +0,0 @@
------BEGIN PGP PUBLIC KEY BLOCK-----
-
-mQINBGZxQOQBEAC1EO1SSoQmzAyAyfQRRHcI4Je5E4mdTchhblLXmuxThquYZ6Xp
-MT3alO6UxDO6aulzd0/RpLviELRwXqEKuUVC9oNbsolWT3sCh0J6ju2LNtmixPIf
-5hd6UQRE32k7AXgwju7bn4TebVkl2fXsdtqSY+57Rs+8G7HiCRDoiYw1S4OwKsuI
-RU7F4VNTV3drfcqpY1JZhMM/oestGqhWfln59kRgvqPDdOlX6Jv1502lElRddHBl
-1f/SnE/mZQJ8Y+zfFuCxkhKZHYLzO3scudUIOHfVt2tLEYYsYK23NFAnF4ECYv+H
-F1PoITbd8WeXoFeMjSr1h19ElzW76eBPvOYzqlzEKQ8b8uQUTqmyZl7HhQOtsIXG
-YBYi3V30I+JBuEGkkhtkbXVET8sE1FCX2xSDOsqshqSiLchlVJxiQlThqZ4prtBC
-byaTmdxFKRsQmSvLv5V9Puel80mzvM/L85s+gop9btygJ+Vpo1Dtdkbvp/jz+k1f
-arZaqAFPE9/rJlMEW8HE12QBYpxiQAl6k0KUu/1MUcTbaZ7wbzQVGHXTmrP9mGff
-9DTPeK01UPJpR9lT/kFwo/ip7nkI0zHcoAgwCGLNHCnbWjjz6ZAzYS9Dj8RG1T13
-g/TjpQtmNWxdPIQ3yZDv30BKFv1aoWLejz4rj19dtPnVClUyMlRPonDDfwARAQAB
-tDRsaWJzc2ggcmVsZWFzZSBrZXkgKHJlbGVhc2Uga2V5KSA8bGlic3NoQGxpYnNz
-aC5vcmc+iQJXBBMBCABBFiEEiKIo2JsHwsd9DHgJA9XfjP3T6OcFAmZxQOQCGwMF
-CRLMAwAFCwkIBwICIgIGFQoJCAsCBBYCAwECHgcCF4AACgkQA9XfjP3T6OfPBA//
-cQA2fdsNyIgAyhppHAtdmKtRaN5dWj9InKZTWRmWNMAU3lTrMCGVurz2tcg2X6Xz
-rVvZuXbLnb6GIRU0ly+nYiBZF4qDL088NtqN7AEEUaabOmlSZr5wXyJObMvlzDg9
-GkjKAKH2CBztROtG3P91uHQ12SDqqIGw5/LlWGUSBzDnChdaB7ntODmjJ8wHqyOy
-tD6GIfy7KkvnD6nyCXvqlZgo0/nr91otkDFbJrF/IobZD1hiBcps7b3oC3ms0e9T
-usk4wl+oUi2LdTIOVvAag17gdkbH7MXMMOwhbNrV5MEyKpleTfm+R+jo48hRwdrn
-LMrDR0+f26bIsWILvGE9GIqvoJD3rKDgjTFwmMcM4OLssCgTTy0h93gDbyBrOmA9
-gJDApWWLq26SkDGIrsp4JcYlcR3m4S2Bjg98PTbz96fATK+AZ/R1Kntbt1J7DcnT
-th3q4jXFIPUzvZA0r7Ul+UM/OfVr/Ryc023oID5po1zeO3HyVKVxXYY/DgpzWTcq
-iwGjWM18XRDhUVV7eOJZ4XRcyDhf4eEF8etwFFraXjVVimCCEqgukEQh9azr+kqi
-IWYoAH0fwVP85u38WqlLS+9in5mKq+lBFI201RpkzsdPDtJMtXTYgw1s6IrQntzF
-w1PIJ/49b7nZhqvp0sMQGlAKfYTQvQsiAuEfzNiFcTS5Ag0EZnFA5AEQAJNgU4Wg
-S+DUP9/wutGn9ADAEIZvD+dxpliKFmtfUeLiNAtaEfxmL7YCazlZbJ7tdhplwfJP
-Es9k7G0K+8k1t+gni9sc7/W/0bB12cbCOxDlfcWATP5RZUfCc7eQVsWm1Sq41W2C
-WGLqp9oC9jd2KGlReE4tj1PUmYtdHDOLBKr3PJrHHTGaF+4Qem5PVx+4ZmaH0qGT
-8CmKYdhE0P8EYNImkmYsCo2nf3tbnjxBNAvwb1ljwJ1djFO72huvHslo6oTuQ+W6
-Bam4m37b+AA/NiXk3RkrL8dwHB/D4G4fk0yflVQFx+0uwYj+Ik5HAri7WISOYfBN
-Yvb6VPm9cdw/ajF0sV4d1bChroLkw0Y9VW5jEkhwGeLexY+bLP+uLOn9CvSd5iZX
-kmamBA5c/jDWAibqgADux3OKNOa7JND38axuc67o5BynfW1iw3osU5fa/jdOxogJ
-xgRq+muWh8rpVGuJHLDcG2TWxC66zEA7Dp8UE/nToIZeP7m6Ihzpo37a33m0BfKH
-qG2cM4EYjIoFDFlbBbk7RogOXTshVc69JhKUaNNh8zSlCOTjwQedqPb7eW+zkPOc
-ZdII3a+oLe4j49+QBiRXoJT3QWhqbxQYF5gnv86o/ZhAUrzEW8KAk8vJAHiKJhe1
-sGHgu0yuiq5Ox4HHBrVBiEgZPxEYo4+xGLz7ABEBAAGJAjwEGAEIACYWIQSIoijY
-mwfCx30MeAkD1d+M/dPo5wUCZnFA5AIbDAUJEswDAAAKCRAD1d+M/dPo523QD/wM
-+Tf6y684Vn1HKMMyDLLCv1fFoSdialbf0gieXIlLm9yH0VaAcnMYFN7flYSekISq
-23uH6ZIcABSfvg4dCCKUUggR3CnUql0SjF9BtFisGiCsDGlH3fNH0d1Ts0FOUdkL
-TH/U676r08DQu1t0iSdOuDxM9FAo926gJSvyorLx7X94KhUeHhXfmzZ88ydz0ked
-KFTKoo/LVhxRIoAGUdl98uJ+oycoELAeg7u0djVk+Hkw6ZLnMsjJBYHV3SyOXBpy
-beQ9O3yK0oNqHW1oIAnHtX/Msqzj+x2+BMpjirsaHWsewnXgDUG/2h1MN67XW1zu
-boztT8zswALbPfkOxS4Y+evaSnq4W6xF4dGuh2sM6g82pyAHdpBPrp4WEKnAcvi4
-5EFNZYpKbQVXnDyK4899CCPcsxj56DlVtJRv167WNRBlU6k6MUVZH0F1JLQpxwx5
-TlohKUa2KBnBZofmCD0xRzV7GbT08KRObSrMqIQU4ILqs2TlhDJhYMurKh7sWKFO
-CX8wWu1TupOt7Zkf/OPapW2konKTu4h36yoPR6D4JZQhd6zZ+4+BsxgzdKCORPM5
-DfSh15+evGapxAdUZrt/N4q2o2TdMcaSu4cZQnqu2soBWiNEa1DeBurCwrHJu/tt
-dEyK6ESk4OGJ2ycirv4skD17gMHNRODFjhAgKgEybg==
-=m20i
------END PGP PUBLIC KEY BLOCK-----

SOURCES/memory_leak.patch

@@ -0,0 +1,514 @@
+From 8795d8912c8a83aaf900c0260e252a35f64eb200 Mon Sep 17 00:00:00 2001
+From: Norbert Pocs <npocs@redhat.com>
+Date: Fri, 18 Nov 2022 17:22:46 +0100
+Subject: [PATCH] Fix memory leaks of bignums when openssl >= 3.0
+
+The openssl 3.0 support has introduced some memory leaks at key build as
+OSSL_PARAM_BLD_push_BN duplicates the bignum and does not save the pointer
+itself.
+
+Signed-off-by: Norbert Pocs <npocs@redhat.com>
+Reviewed-by: Jakub Jelen <jjelen@redhat.com>
+---
+ include/libssh/dh.h |   2 +-
+ src/dh_crypto.c     |  28 ++---
+ src/pki_crypto.c    | 262 ++++++++++++++++++++++++--------------------
+ 3 files changed, 151 insertions(+), 141 deletions(-)
+
+diff --git a/include/libssh/dh.h b/include/libssh/dh.h
+index 353dc233..9b9bb472 100644
+--- a/include/libssh/dh.h
++++ b/include/libssh/dh.h
+@@ -53,7 +53,7 @@ int ssh_dh_keypair_get_keys(struct dh_ctx *ctx, int peer,
+                             bignum *priv, bignum *pub);
+ #endif /* OPENSSL_VERSION_NUMBER */
+ int ssh_dh_keypair_set_keys(struct dh_ctx *ctx, int peer,
+-                            const bignum priv, const bignum pub);
++                            bignum priv, bignum pub);
+
+ int ssh_dh_compute_shared_secret(struct dh_ctx *ctx, int local, int remote,
+                                  bignum *dest);
+diff --git a/src/dh_crypto.c b/src/dh_crypto.c
+index a847c6a2..b578ddec 100644
+--- a/src/dh_crypto.c
++++ b/src/dh_crypto.c
+@@ -154,12 +154,9 @@ int ssh_dh_keypair_get_keys(struct dh_ctx *ctx, int peer,
+ #endif /* OPENSSL_VERSION_NUMBER */
+
+ int ssh_dh_keypair_set_keys(struct dh_ctx *ctx, int peer,
+-                            const bignum priv, const bignum pub)
++                            bignum priv, bignum pub)
+ {
+-#if OPENSSL_VERSION_NUMBER < 0x30000000L
+-    bignum priv_key = NULL;
+-    bignum pub_key = NULL;
+-#else
++#if OPENSSL_VERSION_NUMBER >= 0x30000000L
+     int rc;
+     OSSL_PARAM *params = NULL, *out_params = NULL, *merged_params = NULL;
+     OSSL_PARAM_BLD *param_bld = NULL;
+@@ -172,7 +169,11 @@ int ssh_dh_keypair_set_keys(struct dh_ctx *ctx, int peer,
+         return SSH_ERROR;
+     }
+
+-#if OPENSSL_VERSION_NUMBER >= 0x30000000L
++#if OPENSSL_VERSION_NUMBER < 0x30000000L
++    (void)DH_set0_key(ctx->keypair[peer], pub, priv);
++
++    return SSH_OK;
++#else
+     rc = EVP_PKEY_todata(ctx->keypair[peer], EVP_PKEY_KEYPAIR, &out_params);
+     if (rc != 1) {
+         return SSH_ERROR;
+@@ -195,35 +196,22 @@ int ssh_dh_keypair_set_keys(struct dh_ctx *ctx, int peer,
+         rc = SSH_ERROR;
+         goto out;
+     }
+-#endif /* OPENSSL_VERSION_NUMBER */
+
+     if (priv) {
+-#if OPENSSL_VERSION_NUMBER < 0x30000000L
+-        priv_key = priv;
+-#else
+         rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_PRIV_KEY, priv);
+         if (rc != 1) {
+             rc = SSH_ERROR;
+             goto out;
+         }
+-#endif /* OPENSSL_VERSION_NUMBER */
+     }
+     if (pub) {
+-#if OPENSSL_VERSION_NUMBER < 0x30000000L
+-        pub_key = pub;
+-#else
+         rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_PUB_KEY, pub);
+         if (rc != 1) {
+             rc = SSH_ERROR;
+             goto out;
+         }
+-#endif /* OPENSSL_VERSION_NUMBER */
+     }
+-#if OPENSSL_VERSION_NUMBER < 0x30000000L
+-    (void)DH_set0_key(ctx->keypair[peer], pub_key, priv_key);
+
+-    return SSH_OK;
+-#else
+     params = OSSL_PARAM_BLD_to_param(param_bld);
+     if (params == NULL) {
+         rc = SSH_ERROR;
+@@ -248,6 +236,8 @@ int ssh_dh_keypair_set_keys(struct dh_ctx *ctx, int peer,
+
+     rc = SSH_OK;
+ out:
++    bignum_safe_free(priv);
++    bignum_safe_free(pub);
+     EVP_PKEY_CTX_free(evp_ctx);
+     OSSL_PARAM_free(out_params);
+     OSSL_PARAM_free(params);
+diff --git a/src/pki_crypto.c b/src/pki_crypto.c
+index 0a5003da..d3359e2d 100644
+--- a/src/pki_crypto.c
++++ b/src/pki_crypto.c
+@@ -1492,18 +1492,18 @@ int pki_privkey_build_dss(ssh_key key,
+                           ssh_string privkey)
+ {
+     int rc;
+-#if OPENSSL_VERSION_NUMBER < 0x30000000L
+     BIGNUM *bp, *bq, *bg, *bpub_key, *bpriv_key;
++#if OPENSSL_VERSION_NUMBER >= 0x30000000L
++    OSSL_PARAM_BLD *param_bld = OSSL_PARAM_BLD_new();
++    if (param_bld == NULL) {
++        return SSH_ERROR;
++    }
+ #else
+-    const BIGNUM *pb, *qb, *gb, *pubb, *privb;
+-    OSSL_PARAM_BLD *param_bld;
+-#endif /* OPENSSL_VERSION_NUMBER */
+-
+-#if OPENSSL_VERSION_NUMBER < 0x30000000L
+     key->dsa = DSA_new();
+     if (key->dsa == NULL) {
+         return SSH_ERROR;
+     }
++#endif /* OPENSSL_VERSION_NUMBER */
+
+     bp = ssh_make_string_bn(p);
+     bq = ssh_make_string_bn(q);
+@@ -1512,9 +1512,11 @@ int pki_privkey_build_dss(ssh_key key,
+     bpriv_key = ssh_make_string_bn(privkey);
+     if (bp == NULL || bq == NULL ||
+         bg == NULL || bpub_key == NULL) {
++        rc = SSH_ERROR;
+         goto fail;
+     }
+
++#if OPENSSL_VERSION_NUMBER < 0x30000000L
+     /* Memory management of bp, qq and bg is transferred to DSA object */
+     rc = DSA_set0_pqg(key->dsa, bp, bq, bg);
+     if (rc == 0) {
+@@ -1532,39 +1534,43 @@ fail:
+     DSA_free(key->dsa);
+     return SSH_ERROR;
+ #else
+-    param_bld = OSSL_PARAM_BLD_new();
+-    if (param_bld == NULL)
+-        goto err;
+-
+-    pb = ssh_make_string_bn(p);
+-    qb = ssh_make_string_bn(q);
+-    gb = ssh_make_string_bn(g);
+-    pubb = ssh_make_string_bn(pubkey);
+-    privb = ssh_make_string_bn(privkey);
+-
+-    rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_FFC_P, pb);
+-    if (rc != 1)
+-        goto err;
+-    rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_FFC_Q, qb);
+-    if (rc != 1)
+-        goto err;
+-    rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_FFC_G, gb);
+-    if (rc != 1)
+-        goto err;
+-    rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_PUB_KEY, pubb);
+-    if (rc != 1)
+-        goto err;
+-    rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_PRIV_KEY, privb);
+-    if (rc != 1)
+-        goto err;
++    rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_FFC_P, bp);
++    if (rc != 1) {
++        rc = SSH_ERROR;
++        goto fail;
++    }
++    rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_FFC_Q, bq);
++    if (rc != 1) {
++        rc = SSH_ERROR;
++        goto fail;
++    }
++    rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_FFC_G, bg);
++    if (rc != 1) {
++        rc = SSH_ERROR;
++        goto fail;
++    }
++    rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_PUB_KEY, bpub_key);
++    if (rc != 1) {
++        rc = SSH_ERROR;
++        goto fail;
++    }
++    rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_PRIV_KEY, bpriv_key);
++    if (rc != 1) {
++        rc = SSH_ERROR;
++        goto fail;
++    }
+
+     rc = evp_build_pkey("DSA", param_bld, &(key->key), EVP_PKEY_KEYPAIR);
++
++fail:
+     OSSL_PARAM_BLD_free(param_bld);
++    bignum_safe_free(bp);
++    bignum_safe_free(bq);
++    bignum_safe_free(bg);
++    bignum_safe_free(bpub_key);
++    bignum_safe_free(bpriv_key);
+
+     return rc;
+-err:
+-    OSSL_PARAM_BLD_free(param_bld);
+-    return -1;
+ #endif /* OPENSSL_VERSION_NUMBER */
+ }
+
+@@ -1574,18 +1580,18 @@ int pki_pubkey_build_dss(ssh_key key,
+                          ssh_string g,
+                          ssh_string pubkey) {
+     int rc;
+-#if OPENSSL_VERSION_NUMBER < 0x30000000L
+     BIGNUM *bp = NULL, *bq = NULL, *bg = NULL, *bpub_key = NULL;
++#if OPENSSL_VERSION_NUMBER >= 0x30000000L
++    OSSL_PARAM_BLD *param_bld = OSSL_PARAM_BLD_new();
++    if (param_bld == NULL) {
++        return SSH_ERROR;
++    }
+ #else
+-    const BIGNUM *pb, *qb, *gb, *pubb;
+-    OSSL_PARAM_BLD *param_bld;
+-#endif /* OPENSSL_VERSION_NUMBER */
+-
+-#if OPENSSL_VERSION_NUMBER < 0x30000000L
+     key->dsa = DSA_new();
+     if (key->dsa == NULL) {
+         return SSH_ERROR;
+     }
++#endif /* OPENSSL_VERSION_NUMBER */
+
+     bp = ssh_make_string_bn(p);
+     bq = ssh_make_string_bn(q);
+@@ -1593,9 +1599,11 @@ int pki_pubkey_build_dss(ssh_key key,
+     bpub_key = ssh_make_string_bn(pubkey);
+     if (bp == NULL || bq == NULL ||
+         bg == NULL || bpub_key == NULL) {
++        rc = SSH_ERROR;
+         goto fail;
+     }
+
++#if OPENSSL_VERSION_NUMBER < 0x30000000L
+     /* Memory management of bp, bq and bg is transferred to DSA object */
+     rc = DSA_set0_pqg(key->dsa, bp, bq, bg);
+     if (rc == 0) {
+@@ -1613,35 +1621,37 @@ fail:
+     DSA_free(key->dsa);
+     return SSH_ERROR;
+ #else
+-    param_bld = OSSL_PARAM_BLD_new();
+-    if (param_bld == NULL)
+-        goto err;
+-
+-    pb = ssh_make_string_bn(p);
+-    qb = ssh_make_string_bn(q);
+-    gb = ssh_make_string_bn(g);
+-    pubb = ssh_make_string_bn(pubkey);
+-
+-    rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_FFC_P, pb);
+-    if (rc != 1)
+-        goto err;
+-    rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_FFC_Q, qb);
+-    if (rc != 1)
+-        goto err;
+-    rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_FFC_G, gb);
+-    if (rc != 1)
+-        goto err;
+-    rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_PUB_KEY, pubb);
+-    if (rc != 1)
+-        goto err;
++    rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_FFC_P, bp);
++    if (rc != 1) {
++        rc = SSH_ERROR;
++        goto fail;
++    }
++    rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_FFC_Q, bq);
++    if (rc != 1) {
++        rc = SSH_ERROR;
++        goto fail;
++    }
++    rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_FFC_G, bg);
++    if (rc != 1) {
++        rc = SSH_ERROR;
++        goto fail;
++    }
++    rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_PUB_KEY, bpub_key);
++    if (rc != 1) {
++        rc = SSH_ERROR;
++        goto fail;
++    }
+
+     rc = evp_build_pkey("DSA", param_bld, &(key->key), EVP_PKEY_PUBLIC_KEY);
++
++fail:
+     OSSL_PARAM_BLD_free(param_bld);
++    bignum_safe_free(bp);
++    bignum_safe_free(bq);
++    bignum_safe_free(bg);
++    bignum_safe_free(bpub_key);
+
+     return rc;
+-err:
+-    OSSL_PARAM_BLD_free(param_bld);
+-    return -1;
+ #endif /* OPENSSL_VERSION_NUMBER */
+ }
+
+@@ -1654,18 +1664,18 @@ int pki_privkey_build_rsa(ssh_key key,
+                           ssh_string q)
+ {
+     int rc;
+-#if OPENSSL_VERSION_NUMBER < 0x30000000L
+     BIGNUM *be, *bn, *bd/*, *biqmp*/, *bp, *bq;
++#if OPENSSL_VERSION_NUMBER >= 0x30000000L
++    OSSL_PARAM_BLD *param_bld = OSSL_PARAM_BLD_new();
++    if (param_bld == NULL) {
++        return SSH_ERROR;
++    }
+ #else
+-    const BIGNUM *nb, *eb, *db, *pb, *qb;
+-    OSSL_PARAM_BLD *param_bld;
+-#endif /* OPENSSL_VERSION_NUMBER */
+-
+-#if OPENSSL_VERSION_NUMBER < 0x30000000L
+     key->rsa = RSA_new();
+     if (key->rsa == NULL) {
+         return SSH_ERROR;
+     }
++#endif /* OPENSSL_VERSION_NUMBER */
+
+     bn = ssh_make_string_bn(n);
+     be = ssh_make_string_bn(e);
+@@ -1675,9 +1685,11 @@ int pki_privkey_build_rsa(ssh_key key,
+     bq = ssh_make_string_bn(q);
+     if (be == NULL || bn == NULL || bd == NULL ||
+         /*biqmp == NULL ||*/ bp == NULL || bq == NULL) {
++        rc = SSH_ERROR;
+         goto fail;
+     }
+
++#if OPENSSL_VERSION_NUMBER < 0x30000000L
+     /* Memory management of be, bn and bd is transferred to RSA object */
+     rc = RSA_set0_key(key->rsa, bn, be, bd);
+     if (rc == 0) {
+@@ -1702,41 +1714,49 @@ fail:
+     RSA_free(key->rsa);
+     return SSH_ERROR;
+ #else
+-    param_bld = OSSL_PARAM_BLD_new();
+-    if (param_bld == NULL)
+-        goto err;
+-
+-    nb = ssh_make_string_bn(n);
+-    eb = ssh_make_string_bn(e);
+-    db = ssh_make_string_bn(d);
+-    pb = ssh_make_string_bn(p);
+-    qb = ssh_make_string_bn(q);
+-
+-    rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_RSA_N, nb);
+-    if (rc != 1)
+-        goto err;
+-    rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_RSA_E, eb);
+-    if (rc != 1)
+-        goto err;
+-    rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_RSA_D, db);
+-    if (rc != 1)
+-        goto err;
++    rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_RSA_N, bn);
++    if (rc != 1) {
++        rc = SSH_ERROR;
++        goto fail;
++    }
++    rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_RSA_E, be);
++    if (rc != 1) {
++        rc = SSH_ERROR;
++        goto fail;
++    }
++    rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_RSA_D, bd);
++    if (rc != 1) {
++        rc = SSH_ERROR;
++        goto fail;
++    }
+
+     rc = evp_build_pkey("RSA", param_bld, &(key->key), EVP_PKEY_KEYPAIR);
+-    OSSL_PARAM_BLD_free(param_bld);
++    if (rc != SSH_OK) {
++        rc = SSH_ERROR;
++        goto fail;
++    }
+
+-    rc = EVP_PKEY_set_bn_param(key->key, OSSL_PKEY_PARAM_RSA_FACTOR1, pb);
+-    if (rc != 1)
+-        goto err;
++    rc = EVP_PKEY_set_bn_param(key->key, OSSL_PKEY_PARAM_RSA_FACTOR1, bp);
++    if (rc != 1) {
++        rc = SSH_ERROR;
++        goto fail;
++    }
+
+-    rc = EVP_PKEY_set_bn_param(key->key, OSSL_PKEY_PARAM_RSA_FACTOR2, qb);
+-    if (rc != 1)
+-        goto err;
++    rc = EVP_PKEY_set_bn_param(key->key, OSSL_PKEY_PARAM_RSA_FACTOR2, bq);
++    if (rc != 1) {
++        rc = SSH_ERROR;
++        goto fail;
++    }
+
+-    return rc;
+-err:
++fail:
+     OSSL_PARAM_BLD_free(param_bld);
+-    return -1;
++    bignum_safe_free(bn);
++    bignum_safe_free(be);
++    bignum_safe_free(bd);
++    bignum_safe_free(bp);
++    bignum_safe_free(bq);
++
++    return rc;
+ #endif /* OPENSSL_VERSION_NUMBER */
+ }
+
+@@ -1744,25 +1764,27 @@ int pki_pubkey_build_rsa(ssh_key key,
+                          ssh_string e,
+                          ssh_string n) {
+     int rc;
+-#if OPENSSL_VERSION_NUMBER < 0x30000000L
+     BIGNUM *be = NULL, *bn = NULL;
++#if OPENSSL_VERSION_NUMBER >= 0x30000000L
++    OSSL_PARAM_BLD *param_bld = OSSL_PARAM_BLD_new();
++    if (param_bld == NULL) {
++        return SSH_ERROR;
++    }
+ #else
+-    const BIGNUM *eb, *nb;
+-    OSSL_PARAM_BLD *param_bld;
+-#endif /* OPENSSL_VERSION_NUMBER */
+-
+-#if OPENSSL_VERSION_NUMBER < 0x30000000L
+     key->rsa = RSA_new();
+     if (key->rsa == NULL) {
+         return SSH_ERROR;
+     }
++#endif /* OPENSSL_VERSION_NUMBER */
+
+     be = ssh_make_string_bn(e);
+     bn = ssh_make_string_bn(n);
+     if (be == NULL || bn == NULL) {
++        rc = SSH_ERROR;
+         goto fail;
+     }
+
++#if OPENSSL_VERSION_NUMBER < 0x30000000L
+     /* Memory management of bn and be is transferred to RSA object */
+     rc = RSA_set0_key(key->rsa, bn, be, NULL);
+     if (rc == 0) {
+@@ -1774,27 +1796,25 @@ fail:
+     RSA_free(key->rsa);
+     return SSH_ERROR;
+ #else
+-    nb = ssh_make_string_bn(n);
+-    eb = ssh_make_string_bn(e);
+-
+-    param_bld = OSSL_PARAM_BLD_new();
+-    if (param_bld == NULL)
+-        goto err;
+-
+-    rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_RSA_N, nb);
+-    if (rc != 1)
+-        goto err;
+-    rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_RSA_E, eb);
+-    if (rc != 1)
+-        goto err;
++    rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_RSA_N, bn);
++    if (rc != 1) {
++        rc = SSH_ERROR;
++        goto fail;
++    }
++    rc = OSSL_PARAM_BLD_push_BN(param_bld, OSSL_PKEY_PARAM_RSA_E, be);
++    if (rc != 1) {
++        rc = SSH_ERROR;
++        goto fail;
++    }
+
+     rc = evp_build_pkey("RSA", param_bld, &(key->key), EVP_PKEY_PUBLIC_KEY);
++
++fail:
+     OSSL_PARAM_BLD_free(param_bld);
++    bignum_safe_free(bn);
++    bignum_safe_free(be);
+
+     return rc;
+-err:
+-    OSSL_PARAM_BLD_free(param_bld);
+-    return -1;
+ #endif /* OPENSSL_VERSION_NUMBER */
+ }
+
+--
+2.38.1
+

SOURCES/options_apply.patch

@@ -0,0 +1,842 @@
+From 11c0d687a081fe64501e21c95def7f893611d029 Mon Sep 17 00:00:00 2001
+From: Norbert Pocs <npocs@redhat.com>
+Date: Wed, 16 Nov 2022 10:40:38 +0100
+Subject: [PATCH 1/5] Add a placehohlder for non-expanded identities
+
+Expanding a string twice could lead to unwanted behaviour.
+This solution creates a ssh_list (`opts.identites_non_exp`) to store the strings
+before expansion and by using ssh_apply it moves the string to the
+`opts.identities`. This way the expanded strings are separated.
+
+Signed-off-by: Norbert Pocs <npocs@redhat.com>
+Reviewed-by: Jakub Jelen <jjelen@redhat.com>
+---
+ include/libssh/session.h |  1 +
+ src/options.c            | 86 +++++++++++++++++++++++++---------------
+ src/session.c            | 23 +++++++++--
+ 3 files changed, 75 insertions(+), 35 deletions(-)
+
+diff --git a/include/libssh/session.h b/include/libssh/session.h
+index d3e5787c..e22b0d67 100644
+--- a/include/libssh/session.h
++++ b/include/libssh/session.h
+@@ -209,6 +209,7 @@ struct ssh_session_struct {
+ #endif
+     struct {
+         struct ssh_list *identity;
++        struct ssh_list *identity_non_exp;
+         char *username;
+         char *host;
+         char *bindaddr; /* bind the client to an ip addr */
+diff --git a/src/options.c b/src/options.c
+index 56e09c65..bb085384 100644
+--- a/src/options.c
++++ b/src/options.c
+@@ -52,7 +52,7 @@
+  * @brief Duplicate the options of a session structure.
+  *
+  * If you make several sessions with the same options this is useful. You
+- * cannot use twice the same option structure in ssh_session_connect.
++ * cannot use twice the same option structure in ssh_connect.
+  *
+  * @param src           The session to use to copy the options.
+  *
+@@ -61,13 +61,14 @@
+  *
+  * @returns             0 on success, -1 on error with errno set.
+  *
+- * @see ssh_session_connect()
++ * @see ssh_connect()
+  * @see ssh_free()
+  */
+ int ssh_options_copy(ssh_session src, ssh_session *dest)
+ {
+     ssh_session new;
+     struct ssh_iterator *it = NULL;
++    struct ssh_list *list = NULL;
+     char *id = NULL;
+     int i;
+
+@@ -105,14 +106,15 @@ int ssh_options_copy(ssh_session src, ssh_session *dest)
+     }
+
+     /* Remove the default identities */
+-    for (id = ssh_list_pop_head(char *, new->opts.identity);
++    for (id = ssh_list_pop_head(char *, new->opts.identity_non_exp);
+          id != NULL;
+-         id = ssh_list_pop_head(char *, new->opts.identity)) {
++         id = ssh_list_pop_head(char *, new->opts.identity_non_exp)) {
+         SAFE_FREE(id);
+     }
+     /* Copy the new identities from the source list */
+-    if (src->opts.identity != NULL) {
+-        it = ssh_list_get_iterator(src->opts.identity);
++    list = new->opts.identity_non_exp;
++    it = ssh_list_get_iterator(src->opts.identity_non_exp);
++    for (i = 0; i < 2; i++) {
+         while (it) {
+             int rc;
+
+@@ -122,7 +124,7 @@ int ssh_options_copy(ssh_session src, ssh_session *dest)
+                 return -1;
+             }
+
+-            rc = ssh_list_append(new->opts.identity, id);
++            rc = ssh_list_append(list, id);
+             if (rc < 0) {
+                 free(id);
+                 ssh_free(new);
+@@ -130,6 +132,10 @@ int ssh_options_copy(ssh_session src, ssh_session *dest)
+             }
+             it = it->next;
+         }
++
++        /* copy the identity list if there is any already */
++        list = new->opts.identity;
++        it = ssh_list_get_iterator(src->opts.identity);
+     }
+
+     if (src->opts.sshdir != NULL) {
+@@ -331,7 +337,7 @@ int ssh_options_set_algo(ssh_session session,
+  *                Add a new identity file (const char *, format string) to
+  *                the identity list.\n
+  *                \n
+- *                By default identity, id_dsa and id_rsa are checked.\n
++ *                By default id_rsa, id_ecdsa and id_ed25519 files are used.\n
+  *                \n
+  *                The identity used to authenticate with public key will be
+  *                prepended to the list.
+@@ -700,7 +706,11 @@ int ssh_options_set(ssh_session session, enum ssh_options_e type,
+             if (q == NULL) {
+                 return -1;
+             }
+-            rc = ssh_list_prepend(session->opts.identity, q);
++            if (session->opts.exp_flags & SSH_OPT_EXP_FLAG_IDENTITY) {
++                rc = ssh_list_append(session->opts.identity_non_exp, q);
++            } else {
++                rc = ssh_list_prepend(session->opts.identity_non_exp, q);
++            }
+             if (rc < 0) {
+                 free(q);
+                 return -1;
+@@ -1202,7 +1212,7 @@ int ssh_options_get_port(ssh_session session, unsigned int* port_target) {
+  *              - SSH_OPTIONS_IDENTITY:
+  *                Get the first identity file name (const char *).\n
+  *                \n
+- *                By default identity, id_dsa and id_rsa are checked.
++ *                By default id_rsa, id_ecdsa and id_ed25519 files are used.
+  *
+  *              - SSH_OPTIONS_PROXYCOMMAND:
+  *                Get the proxycommand necessary to log into the
+@@ -1246,7 +1256,11 @@ int ssh_options_get(ssh_session session, enum ssh_options_e type, char** value)
+             break;
+         }
+         case SSH_OPTIONS_IDENTITY: {
+-            struct ssh_iterator *it = ssh_list_get_iterator(session->opts.identity);
++            struct ssh_iterator *it;
++            it = ssh_list_get_iterator(session->opts.identity);
++            if (it == NULL) {
++                it = ssh_list_get_iterator(session->opts.identity_non_exp);
++            }
+             if (it == NULL) {
+                 return SSH_ERROR;
+             }
+@@ -1541,7 +1555,6 @@ out:
+
+ int ssh_options_apply(ssh_session session)
+ {
+-    struct ssh_iterator *it;
+     char *tmp;
+     int rc;
+
+@@ -1586,15 +1599,17 @@ int ssh_options_apply(ssh_session session)
+         size_t plen = strlen(session->opts.ProxyCommand) +
+                       5 /* strlen("exec ") */;
+
+-        p = malloc(plen + 1 /* \0 */);
+-        if (p == NULL) {
+-            return -1;
+-        }
++        if (strncmp(session->opts.ProxyCommand, "exec ", 5) != 0) {
++            p = malloc(plen + 1 /* \0 */);
++            if (p == NULL) {
++                return -1;
++            }
+
+-        rc = snprintf(p, plen + 1, "exec %s", session->opts.ProxyCommand);
+-        if ((size_t)rc != plen) {
+-            free(p);
+-            return -1;
++            rc = snprintf(p, plen + 1, "exec %s", session->opts.ProxyCommand);
++            if ((size_t)rc != plen) {
++                free(p);
++                return -1;
++            }
+         }
+
+         tmp = ssh_path_expand_escape(session, p);
+@@ -1606,24 +1621,33 @@ int ssh_options_apply(ssh_session session)
+         session->opts.ProxyCommand = tmp;
+     }
+
+-    for (it = ssh_list_get_iterator(session->opts.identity);
+-         it != NULL;
+-         it = it->next) {
+-        char *id = (char *) it->data;
+-        if (strncmp(id, "pkcs11:", 6) == 0) {
++    for (tmp = ssh_list_pop_head(char *, session->opts.identity_non_exp);
++         tmp != NULL;
++         tmp = ssh_list_pop_head(char *, session->opts.identity_non_exp)) {
++        char *id = tmp;
++        if (strncmp(id, "pkcs11:", 6) != 0) {
+             /* PKCS#11 URIs are using percent-encoding so we can not mix
+              * it with ssh expansion of ssh escape characters.
+-             * Skip these identities now, before we will have PKCS#11 support
+              */
+-             continue;
++            tmp = ssh_path_expand_escape(session, id);
++            if (tmp == NULL) {
++                return -1;
++            }
++            free(id);
+         }
+-        tmp = ssh_path_expand_escape(session, id);
+-        if (tmp == NULL) {
++
++        /* use append to keep the order at first call and use prepend
++         * to put anything that comes on the nth calls to the beginning */
++        if (session->opts.exp_flags & SSH_OPT_EXP_FLAG_IDENTITY) {
++            rc = ssh_list_prepend(session->opts.identity, tmp);
++        } else {
++            rc = ssh_list_append(session->opts.identity, tmp);
++        }
++        if (rc != SSH_OK) {
+             return -1;
+         }
+-        free(id);
+-        it->data = tmp;
+     }
++    session->opts.exp_flags |= SSH_OPT_EXP_FLAG_IDENTITY;
+
+     return 0;
+ }
+diff --git a/src/session.c b/src/session.c
+index 64e54957..34a492e4 100644
+--- a/src/session.c
++++ b/src/session.c
+@@ -118,13 +118,17 @@ ssh_session ssh_new(void)
+     if (session->opts.identity == NULL) {
+         goto err;
+     }
++    session->opts.identity_non_exp = ssh_list_new();
++    if (session->opts.identity_non_exp == NULL) {
++        goto err;
++    }
+
+     id = strdup("%d/id_ed25519");
+     if (id == NULL) {
+         goto err;
+     }
+
+-    rc = ssh_list_append(session->opts.identity, id);
++    rc = ssh_list_append(session->opts.identity_non_exp, id);
+     if (rc == SSH_ERROR) {
+         goto err;
+     }
+@@ -134,7 +138,7 @@ ssh_session ssh_new(void)
+     if (id == NULL) {
+         goto err;
+     }
+-    rc = ssh_list_append(session->opts.identity, id);
++    rc = ssh_list_append(session->opts.identity_non_exp, id);
+     if (rc == SSH_ERROR) {
+         goto err;
+     }
+@@ -144,7 +148,7 @@ ssh_session ssh_new(void)
+     if (id == NULL) {
+         goto err;
+     }
+-    rc = ssh_list_append(session->opts.identity, id);
++    rc = ssh_list_append(session->opts.identity_non_exp, id);
+     if (rc == SSH_ERROR) {
+         goto err;
+     }
+@@ -154,7 +158,7 @@ ssh_session ssh_new(void)
+     if (id == NULL) {
+         goto err;
+     }
+-    rc = ssh_list_append(session->opts.identity, id);
++    rc = ssh_list_append(session->opts.identity_non_exp, id);
+     if (rc == SSH_ERROR) {
+         goto err;
+     }
+@@ -284,6 +288,17 @@ void ssh_free(ssh_session session)
+       ssh_list_free(session->opts.identity);
+   }
+
++  if (session->opts.identity_non_exp) {
++      char *id;
++
++      for (id = ssh_list_pop_head(char *, session->opts.identity_non_exp);
++           id != NULL;
++           id = ssh_list_pop_head(char *, session->opts.identity_non_exp)) {
++          SAFE_FREE(id);
++      }
++      ssh_list_free(session->opts.identity_non_exp);
++  }
++
+     while ((b = ssh_list_pop_head(struct ssh_buffer_struct *,
+                                   session->out_queue)) != NULL) {
+         SSH_BUFFER_FREE(b);
+--
+2.38.1
+
+
+From 4cb84b99fdb1ffd26c0241f5809e4f67ddd407c6 Mon Sep 17 00:00:00 2001
+From: Norbert Pocs <npocs@redhat.com>
+Date: Wed, 16 Nov 2022 11:03:30 +0100
+Subject: [PATCH 2/5] tests: Use opts.identites_non_exp not opts.identities
+
+The configuration of identities are first saved to `opts.identities_non_exp`,
+then moved to `opts.identities` after calling ssh_options_apply and expanding
+the identity strings. These tests are testing against the proper configuration
+
+Signed-off-by: Norbert Pocs <npocs@redhat.com>
+Reviewed-by: Jakub Jelen <jjelen@redhat.com>
+---
+ tests/client/torture_auth_pkcs11.c |  2 +-
+ tests/unittests/torture_config.c   |  3 ++-
+ tests/unittests/torture_options.c  | 14 +++++++-------
+ 3 files changed, 10 insertions(+), 9 deletions(-)
+
+diff --git a/tests/client/torture_auth_pkcs11.c b/tests/client/torture_auth_pkcs11.c
+index ee97bff4..e75fea0e 100644
+--- a/tests/client/torture_auth_pkcs11.c
++++ b/tests/client/torture_auth_pkcs11.c
+@@ -196,7 +196,7 @@ static void torture_auth_autopubkey(void **state, const char *obj_name, const ch
+
+     rc = ssh_options_set(session, SSH_OPTIONS_IDENTITY, priv_uri);
+     assert_int_equal(rc, SSH_OK);
+-    assert_string_equal(session->opts.identity->root->data, priv_uri);
++    assert_string_equal(session->opts.identity_non_exp->root->data, priv_uri);
+
+     rc = ssh_connect(session);
+     assert_int_equal(rc, SSH_OK);
+diff --git a/tests/unittests/torture_config.c b/tests/unittests/torture_config.c
+index 354adc2f..100e68f6 100644
+--- a/tests/unittests/torture_config.c
++++ b/tests/unittests/torture_config.c
+@@ -2078,7 +2078,8 @@ static void torture_config_identity(void **state)
+
+     _parse_config(session, NULL, LIBSSH_TESTCONFIG_STRING13, SSH_OK);
+
+-    it = ssh_list_get_iterator(session->opts.identity);
++    /* The identities are first added to this temporary list before expanding */
++    it = ssh_list_get_iterator(session->opts.identity_non_exp);
+     assert_non_null(it);
+     id = it->data;
+     /* The identities are prepended to the list so we start with second one */
+diff --git a/tests/unittests/torture_options.c b/tests/unittests/torture_options.c
+index dc4df383..3be2de8a 100644
+--- a/tests/unittests/torture_options.c
++++ b/tests/unittests/torture_options.c
+@@ -406,12 +406,12 @@ static void torture_options_set_identity(void **state) {
+
+     rc = ssh_options_set(session, SSH_OPTIONS_ADD_IDENTITY, "identity1");
+     assert_true(rc == 0);
+-    assert_string_equal(session->opts.identity->root->data, "identity1");
++    assert_string_equal(session->opts.identity_non_exp->root->data, "identity1");
+
+     rc = ssh_options_set(session, SSH_OPTIONS_IDENTITY, "identity2");
+     assert_true(rc == 0);
+-    assert_string_equal(session->opts.identity->root->data, "identity2");
+-    assert_string_equal(session->opts.identity->root->next->data, "identity1");
++    assert_string_equal(session->opts.identity_non_exp->root->data, "identity2");
++    assert_string_equal(session->opts.identity_non_exp->root->next->data, "identity1");
+ }
+
+ static void torture_options_get_identity(void **state) {
+@@ -429,7 +429,7 @@ static void torture_options_get_identity(void **state) {
+
+     rc = ssh_options_set(session, SSH_OPTIONS_IDENTITY, "identity2");
+     assert_int_equal(rc, SSH_OK);
+-    assert_string_equal(session->opts.identity->root->data, "identity2");
++    assert_string_equal(session->opts.identity_non_exp->root->data, "identity2");
+     rc = ssh_options_get(session, SSH_OPTIONS_IDENTITY, &identity);
+     assert_int_equal(rc, SSH_OK);
+     assert_non_null(identity);
+@@ -867,9 +867,9 @@ static void torture_options_copy(void **state)
+     assert_non_null(new);
+
+     /* Check the identities match */
+-    it = ssh_list_get_iterator(session->opts.identity);
++    it = ssh_list_get_iterator(session->opts.identity_non_exp);
+     assert_non_null(it);
+-    it2 = ssh_list_get_iterator(new->opts.identity);
++    it2 = ssh_list_get_iterator(new->opts.identity_non_exp);
+     assert_non_null(it2);
+     while (it != NULL && it2 != NULL) {
+         assert_string_equal(it->data, it2->data);
+@@ -956,7 +956,7 @@ static void torture_options_getopt(void **state)
+                         "aes128-ctr");
+     assert_string_equal(session->opts.wanted_methods[SSH_CRYPT_S_C],
+                         "aes128-ctr");
+-    assert_string_equal(session->opts.identity->root->data, "id_rsa");
++    assert_string_equal(session->opts.identity_non_exp->root->data, "id_rsa");
+ #ifdef WITH_ZLIB
+     assert_string_equal(session->opts.wanted_methods[SSH_COMP_C_S],
+                         "zlib@openssh.com,zlib,none");
+--
+2.38.1
+
+
+From cd30217c9032419ebcf722c0bfc6b5ebfa3518d0 Mon Sep 17 00:00:00 2001
+From: Norbert Pocs <npocs@redhat.com>
+Date: Wed, 16 Nov 2022 16:51:02 +0100
+Subject: [PATCH 3/5] Add flags for escape expand operation
+
+Calling `ssh_options_apply` more times can result in an unwanted behaviour of
+expanding the escape characters more times. Adding flags to check if the
+expansion was already done on the current string variables.
+
+Signed-off-by: Norbert Pocs <npocs@redhat.com>
+Reviewed-by: Jakub Jelen <jjelen@redhat.com>
+---
+ include/libssh/session.h |  7 ++++
+ src/options.c            | 91 ++++++++++++++++++++++++----------------
+ src/session.c            |  2 +
+ 3 files changed, 63 insertions(+), 37 deletions(-)
+
+diff --git a/include/libssh/session.h b/include/libssh/session.h
+index e22b0d67..cf219c2a 100644
+--- a/include/libssh/session.h
++++ b/include/libssh/session.h
+@@ -93,6 +93,12 @@ enum ssh_pending_call_e {
+ #define SSH_OPT_FLAG_KBDINT_AUTH 0x4
+ #define SSH_OPT_FLAG_GSSAPI_AUTH 0x8
+
++/* Escape expansion of different variables */
++#define SSH_OPT_EXP_FLAG_KNOWNHOSTS 0x1
++#define SSH_OPT_EXP_FLAG_GLOBAL_KNOWNHOSTS 0x2
++#define SSH_OPT_EXP_FLAG_PROXYCOMMAND 0x4
++#define SSH_OPT_EXP_FLAG_IDENTITY 0x8
++
+ /* extensions flags */
+ /* negotiation enabled */
+ #define SSH_EXT_NEGOTIATION     0x01
+@@ -232,6 +238,7 @@ struct ssh_session_struct {
+         char *gss_client_identity;
+         int gss_delegate_creds;
+         int flags;
++        int exp_flags;
+         int nodelay;
+         bool config_processed;
+         uint8_t options_seen[SOC_MAX];
+diff --git a/src/options.c b/src/options.c
+index bb085384..c566244b 100644
+--- a/src/options.c
++++ b/src/options.c
+@@ -730,6 +730,7 @@ int ssh_options_set(ssh_session session, enum ssh_options_e type,
+                     ssh_set_error_oom(session);
+                     return -1;
+                 }
++                session->opts.exp_flags &= ~SSH_OPT_EXP_FLAG_KNOWNHOSTS;
+             }
+             break;
+         case SSH_OPTIONS_GLOBAL_KNOWNHOSTS:
+@@ -751,6 +752,7 @@ int ssh_options_set(ssh_session session, enum ssh_options_e type,
+                     ssh_set_error_oom(session);
+                     return -1;
+                 }
++                session->opts.exp_flags &= ~SSH_OPT_EXP_FLAG_GLOBAL_KNOWNHOSTS;
+             }
+             break;
+         case SSH_OPTIONS_TIMEOUT:
+@@ -1014,6 +1016,7 @@ int ssh_options_set(ssh_session session, enum ssh_options_e type,
+                         return -1;
+                     }
+                     session->opts.ProxyCommand = q;
++                    session->opts.exp_flags &= ~SSH_OPT_EXP_FLAG_PROXYCOMMAND;
+                 }
+             }
+             break;
+@@ -1572,53 +1575,67 @@ int ssh_options_apply(ssh_session session)
+         }
+     }
+
+-    if (session->opts.knownhosts == NULL) {
+-        tmp = ssh_path_expand_escape(session, "%d/known_hosts");
+-    } else {
+-        tmp = ssh_path_expand_escape(session, session->opts.knownhosts);
+-    }
+-    if (tmp == NULL) {
+-        return -1;
++    if ((session->opts.exp_flags & SSH_OPT_EXP_FLAG_KNOWNHOSTS) == 0) {
++        if (session->opts.knownhosts == NULL) {
++            tmp = ssh_path_expand_escape(session, "%d/known_hosts");
++        } else {
++            tmp = ssh_path_expand_escape(session, session->opts.knownhosts);
++        }
++        if (tmp == NULL) {
++            return -1;
++        }
++        free(session->opts.knownhosts);
++        session->opts.knownhosts = tmp;
++        session->opts.exp_flags |= SSH_OPT_EXP_FLAG_KNOWNHOSTS;
+     }
+-    free(session->opts.knownhosts);
+-    session->opts.knownhosts = tmp;
+
+-    if (session->opts.global_knownhosts == NULL) {
+-        tmp = strdup("/etc/ssh/ssh_known_hosts");
+-    } else {
+-        tmp = ssh_path_expand_escape(session, session->opts.global_knownhosts);
+-    }
+-    if (tmp == NULL) {
+-        return -1;
++    if ((session->opts.exp_flags & SSH_OPT_EXP_FLAG_GLOBAL_KNOWNHOSTS) == 0) {
++        if (session->opts.global_knownhosts == NULL) {
++            tmp = strdup("/etc/ssh/ssh_known_hosts");
++        } else {
++            tmp = ssh_path_expand_escape(session,
++                                         session->opts.global_knownhosts);
++        }
++        if (tmp == NULL) {
++            return -1;
++        }
++        free(session->opts.global_knownhosts);
++        session->opts.global_knownhosts = tmp;
++        session->opts.exp_flags |= SSH_OPT_EXP_FLAG_GLOBAL_KNOWNHOSTS;
+     }
+-    free(session->opts.global_knownhosts);
+-    session->opts.global_knownhosts = tmp;
+
+-    if (session->opts.ProxyCommand != NULL) {
+-        char *p = NULL;
+-        size_t plen = strlen(session->opts.ProxyCommand) +
+-                      5 /* strlen("exec ") */;
+
+-        if (strncmp(session->opts.ProxyCommand, "exec ", 5) != 0) {
+-            p = malloc(plen + 1 /* \0 */);
+-            if (p == NULL) {
+-                return -1;
+-            }
++    if ((session->opts.exp_flags & SSH_OPT_EXP_FLAG_PROXYCOMMAND) == 0) {
++        if (session->opts.ProxyCommand != NULL) {
++            char *p = NULL;
++            size_t plen = strlen(session->opts.ProxyCommand) +
++                          5 /* strlen("exec ") */;
++
++            if (strncmp(session->opts.ProxyCommand, "exec ", 5) != 0) {
++                p = malloc(plen + 1 /* \0 */);
++                if (p == NULL) {
++                    return -1;
++                }
+
+-            rc = snprintf(p, plen + 1, "exec %s", session->opts.ProxyCommand);
+-            if ((size_t)rc != plen) {
++                rc = snprintf(p, plen + 1, "exec %s", session->opts.ProxyCommand);
++                if ((size_t)rc != plen) {
++                    free(p);
++                    return -1;
++                }
++                tmp = ssh_path_expand_escape(session, p);
+                 free(p);
+-                return -1;
++            } else {
++                tmp = ssh_path_expand_escape(session,
++                                             session->opts.ProxyCommand);
+             }
+-        }
+
+-        tmp = ssh_path_expand_escape(session, p);
+-        free(p);
+-        if (tmp == NULL) {
+-            return -1;
++            if (tmp == NULL) {
++                return -1;
++            }
++            free(session->opts.ProxyCommand);
++            session->opts.ProxyCommand = tmp;
++            session->opts.exp_flags |= SSH_OPT_EXP_FLAG_PROXYCOMMAND;
+         }
+-        free(session->opts.ProxyCommand);
+-        session->opts.ProxyCommand = tmp;
+     }
+
+     for (tmp = ssh_list_pop_head(char *, session->opts.identity_non_exp);
+diff --git a/src/session.c b/src/session.c
+index 34a492e4..06f6a26f 100644
+--- a/src/session.c
++++ b/src/session.c
+@@ -114,6 +114,8 @@ ssh_session ssh_new(void)
+                           SSH_OPT_FLAG_KBDINT_AUTH |
+                           SSH_OPT_FLAG_GSSAPI_AUTH;
+
++    session->opts.exp_flags = 0;
++
+     session->opts.identity = ssh_list_new();
+     if (session->opts.identity == NULL) {
+         goto err;
+--
+2.38.1
+
+
+From ed58082f9706f2ab3bdeca24f632356b9bc325e6 Mon Sep 17 00:00:00 2001
+From: Norbert Pocs <npocs@redhat.com>
+Date: Wed, 16 Nov 2022 17:17:14 +0100
+Subject: [PATCH 4/5] torture_options.c: Add identity test for ssh_options_copy
+
+Test if the ssh_options_apply is called on session before ssh_options_copy,
+then `opts.identity` ssh_list will be copied
+
+Signed-off-by: Norbert Pocs <npocs@redhat.com>
+Reviewed-by: Jakub Jelen <jjelen@redhat.com>
+---
+ tests/unittests/torture_options.c | 28 ++++++++++++++++++++++++++++
+ 1 file changed, 28 insertions(+)
+
+diff --git a/tests/unittests/torture_options.c b/tests/unittests/torture_options.c
+index 3be2de8a..907cc8df 100644
+--- a/tests/unittests/torture_options.c
++++ b/tests/unittests/torture_options.c
+@@ -918,6 +918,34 @@ static void torture_options_copy(void **state)
+                         sizeof(session->opts.options_seen));
+
+     ssh_free(new);
++
++    /* test if ssh_options_apply was called before ssh_options_copy
++     * the opts.identity list gets copied (percent expanded list) */
++    rv = ssh_options_apply(session);
++    assert_ssh_return_code(session, rv);
++
++    rv = ssh_options_copy(session, &new);
++    assert_ssh_return_code(session, rv);
++    assert_non_null(new);
++
++    it = ssh_list_get_iterator(session->opts.identity_non_exp);
++    assert_null(it);
++    it2 = ssh_list_get_iterator(new->opts.identity_non_exp);
++    assert_null(it2);
++
++    it = ssh_list_get_iterator(session->opts.identity);
++    assert_non_null(it);
++    it2 = ssh_list_get_iterator(new->opts.identity);
++    assert_non_null(it2);
++    while (it != NULL && it2 != NULL) {
++        assert_string_equal(it->data, it2->data);
++        it = it->next;
++        it2 = it2->next;
++    }
++    assert_null(it);
++    assert_null(it2);
++
++    ssh_free(new);
+ }
+
+ #define EXECUTABLE_NAME "test-exec"
+--
+2.38.1
+
+
+From 89dd4a927b946d4df5c48073ca25cd843e0acde0 Mon Sep 17 00:00:00 2001
+From: Norbert Pocs <npocs@redhat.com>
+Date: Wed, 16 Nov 2022 17:18:49 +0100
+Subject: [PATCH 5/5] torture_options.c: Add test for ssh_options_apply
+
+Test that ssh_options_apply can be called multiple times without expanding
+escape characters more than once. If the options are updated after calling
+ssh_options_apply keep the last options.
+
+Signed-off-by: Norbert Pocs <npocs@redhat.com>
+Reviewed-by: Jakub Jelen <jjelen@redhat.com>
+---
+ tests/unittests/torture_options.c | 165 ++++++++++++++++++++++++++++++
+ 1 file changed, 165 insertions(+)
+
+diff --git a/tests/unittests/torture_options.c b/tests/unittests/torture_options.c
+index 907cc8df..ea63b45e 100644
+--- a/tests/unittests/torture_options.c
++++ b/tests/unittests/torture_options.c
+@@ -1332,6 +1332,170 @@ static void torture_options_caret_sign(void **state)
+     free(awaited);
+ }
+
++static void torture_options_apply (void **state) {
++    ssh_session session = *state;
++    struct ssh_list *awaited_list = NULL;
++    struct ssh_iterator *it1 = NULL, *it2 = NULL;
++    char *id = NULL;
++    int rc;
++
++    rc = ssh_options_set(session,
++                         SSH_OPTIONS_KNOWNHOSTS,
++                         "%%d/.ssh/known_hosts");
++    assert_ssh_return_code(session, rc);
++
++    rc = ssh_options_set(session,
++                         SSH_OPTIONS_GLOBAL_KNOWNHOSTS,
++                         "/etc/%%u/libssh/known_hosts");
++    assert_ssh_return_code(session, rc);
++
++    rc = ssh_options_set(session,
++                         SSH_OPTIONS_PROXYCOMMAND,
++                         "exec echo \"Hello libssh %%d!\"");
++    assert_ssh_return_code(session, rc);
++
++    rc = ssh_options_set(session,
++                         SSH_OPTIONS_ADD_IDENTITY,
++                         "%%d/do_not_expand");
++    assert_ssh_return_code(session, rc);
++
++    rc = ssh_options_apply(session);
++    assert_ssh_return_code(session, rc);
++
++    /* check that the values got expanded */
++    assert_true(session->opts.exp_flags & SSH_OPT_EXP_FLAG_KNOWNHOSTS);
++    assert_true(session->opts.exp_flags & SSH_OPT_EXP_FLAG_GLOBAL_KNOWNHOSTS);
++    assert_true(session->opts.exp_flags & SSH_OPT_EXP_FLAG_PROXYCOMMAND);
++    assert_true(ssh_list_count(session->opts.identity_non_exp) == 0);
++    assert_true(ssh_list_count(session->opts.identity) > 0);
++
++    /* should not change anything calling it again */
++    rc = ssh_options_apply(session);
++    assert_ssh_return_code(session, rc);
++
++    /* check that the expansion was done only once */
++    assert_string_equal(session->opts.knownhosts, "%d/.ssh/known_hosts");
++    assert_string_equal(session->opts.global_knownhosts,
++                        "/etc/%u/libssh/known_hosts");
++    /* no exec should be added if there already is one */
++    assert_string_equal(session->opts.ProxyCommand,
++                        "exec echo \"Hello libssh %d!\"");
++    assert_string_equal(session->opts.identity->root->data,
++                        "%d/do_not_expand");
++
++    /* apply should keep the freshest setting */
++    rc = ssh_options_set(session,
++                         SSH_OPTIONS_KNOWNHOSTS,
++                         "hello there");
++    assert_ssh_return_code(session, rc);
++
++    rc = ssh_options_set(session,
++                         SSH_OPTIONS_GLOBAL_KNOWNHOSTS,
++                         "lorem ipsum");
++    assert_ssh_return_code(session, rc);
++
++    rc = ssh_options_set(session,
++                         SSH_OPTIONS_PROXYCOMMAND,
++                         "mission_impossible");
++    assert_ssh_return_code(session, rc);
++
++    rc = ssh_options_set(session,
++                         SSH_OPTIONS_ADD_IDENTITY,
++                         "007");
++    assert_ssh_return_code(session, rc);
++
++    rc = ssh_options_set(session,
++                         SSH_OPTIONS_ADD_IDENTITY,
++                         "3");
++    assert_ssh_return_code(session, rc);
++
++    rc = ssh_options_set(session,
++                         SSH_OPTIONS_ADD_IDENTITY,
++                         "2");
++    assert_ssh_return_code(session, rc);
++
++    rc = ssh_options_set(session,
++                         SSH_OPTIONS_ADD_IDENTITY,
++                         "1");
++    assert_ssh_return_code(session, rc);
++
++    /* check that flags show need of escape expansion */
++    assert_false(session->opts.exp_flags & SSH_OPT_EXP_FLAG_KNOWNHOSTS);
++    assert_false(session->opts.exp_flags & SSH_OPT_EXP_FLAG_GLOBAL_KNOWNHOSTS);
++    assert_false(session->opts.exp_flags & SSH_OPT_EXP_FLAG_PROXYCOMMAND);
++    assert_false(ssh_list_count(session->opts.identity_non_exp) == 0);
++
++    rc = ssh_options_apply(session);
++    assert_ssh_return_code(session, rc);
++
++    /* check that the values got expanded */
++    assert_true(session->opts.exp_flags & SSH_OPT_EXP_FLAG_KNOWNHOSTS);
++    assert_true(session->opts.exp_flags & SSH_OPT_EXP_FLAG_GLOBAL_KNOWNHOSTS);
++    assert_true(session->opts.exp_flags & SSH_OPT_EXP_FLAG_PROXYCOMMAND);
++    assert_true(ssh_list_count(session->opts.identity_non_exp) == 0);
++
++    assert_string_equal(session->opts.knownhosts, "hello there");
++    assert_string_equal(session->opts.global_knownhosts, "lorem ipsum");
++    /* check that the "exec " was added at the beginning */
++    assert_string_equal(session->opts.ProxyCommand, "exec mission_impossible");
++    assert_string_equal(session->opts.identity->root->data, "1");
++
++    /* check the order of the identity files after double expansion */
++    awaited_list = ssh_list_new();
++    /* append the new data in order */
++    id = strdup("1");
++    rc = ssh_list_append(awaited_list, id);
++    assert_int_equal(rc, SSH_OK);
++    id = strdup("2");
++    rc = ssh_list_append(awaited_list, id);
++    assert_int_equal(rc, SSH_OK);
++    id = strdup("3");
++    rc = ssh_list_append(awaited_list, id);
++    assert_int_equal(rc, SSH_OK);
++    id = strdup("007");
++    rc = ssh_list_append(awaited_list, id);
++    assert_int_equal(rc, SSH_OK);
++    id = strdup("%d/do_not_expand");
++    rc = ssh_list_append(awaited_list, id);
++    assert_int_equal(rc, SSH_OK);
++    /* append the defaults; this list is copied from ssh_new@src/session.c */
++    id = ssh_path_expand_escape(session, "%d/id_ed25519");
++    rc = ssh_list_append(awaited_list, id);
++    assert_int_equal(rc, SSH_OK);
++#ifdef HAVE_ECC
++    id = ssh_path_expand_escape(session, "%d/id_ecdsa");
++    rc = ssh_list_append(awaited_list, id);
++    assert_int_equal(rc, SSH_OK);
++#endif
++    id = ssh_path_expand_escape(session, "%d/id_rsa");
++    rc = ssh_list_append(awaited_list, id);
++    assert_int_equal(rc, SSH_OK);
++#ifdef HAVE_DSA
++    id = ssh_path_expand_escape(session, "%d/id_dsa");
++    rc = ssh_list_append(awaited_list, id);
++    assert_int_equal(rc, SSH_OK);
++#endif
++
++    assert_int_equal(ssh_list_count(awaited_list),
++                     ssh_list_count(session->opts.identity));
++
++    it1 = ssh_list_get_iterator(awaited_list);
++    assert_non_null(it1);
++    it2 = ssh_list_get_iterator(session->opts.identity);
++    assert_non_null(it2);
++    while (it1 != NULL && it2 != NULL) {
++        assert_string_equal(it1->data, it2->data);
++
++        free((void*)it1->data);
++        it1 = it1->next;
++        it2 = it2->next;
++    }
++    assert_null(it1);
++    assert_null(it2);
++
++    ssh_list_free(awaited_list);
++}
++
+ #ifdef WITH_SERVER
+ const char template[] = "temp_dir_XXXXXX";
+
+@@ -2132,6 +2296,7 @@ int torture_run_tests(void) {
+                                         setup, teardown),
+         cmocka_unit_test_setup_teardown(torture_options_caret_sign,
+                                         setup, teardown),
++        cmocka_unit_test_setup_teardown(torture_options_apply, setup, teardown),
+     };
+
+ #ifdef WITH_SERVER
+--
+2.38.1
+

SOURCES/pkcs11_test_fix.patch

@@ -0,0 +1,98 @@
+diff --git a/tests/pkcs11/setup-softhsm-tokens.sh b/tests/pkcs11/setup-softhsm-tokens.sh
+index 532c86a7..9050cea6 100755
+--- a/tests/pkcs11/setup-softhsm-tokens.sh
++++ b/tests/pkcs11/setup-softhsm-tokens.sh
+@@ -17,10 +17,10 @@ echo "OBJNAME: $OBJNAME"
+ echo "LOADPUBLIC: $LOADPUBLIC"
+
+ # Create temporary directory for tokens
+-install -d -m 0755 $TESTDIR/db
++install -d -m 0755 "$TESTDIR/db"
+
+ # Create SoftHSM configuration file
+-cat >$TESTDIR/softhsm.conf <<EOF
++cat >"$TESTDIR/softhsm.conf" <<EOF
+ directories.tokendir = $TESTDIR/db
+ objectstore.backend = file
+ log.level = DEBUG
+@@ -28,12 +28,12 @@ EOF
+
+ export SOFTHSM2_CONF=$TESTDIR/softhsm.conf
+
+-cat $TESTDIR/softhsm.conf
++cat "$TESTDIR/softhsm.conf"
+
+ #init
+-cmd='softhsm2-util --init-token --label "$OBJNAME" --free --pin 1234 --so-pin 1234'
++cmd="softhsm2-util --init-token --label $OBJNAME --free --pin 1234 --so-pin 1234"
+ eval echo "$cmd"
+-out=$(eval $cmd)
++out=$(eval "$cmd")
+ ret=$?
+ if [ $ret -ne 0 ]; then
+     echo "Init token failed"
+@@ -41,10 +41,29 @@ if [ $ret -ne 0 ]; then
+     exit 1
+ fi
+
++find_library_path() {
++    echo "$@"
++    for _lib in "$@" ; do
++        if test -f "$_lib" ; then
++            LIBSOFTHSM_PATH="$_lib"
++            echo "Using libsofthsm path: $LIBSOFTHSM_PATH"
++            return
++        fi
++    done
++    echo "libsofthsm2.so not found"
++    exit 1
++}
++
++find_library_path \
++    /usr/lib64/libsofthsm2.so \
++    /usr/lib/libsofthsm2.so \
++    /usr/local/lib/softhsm/libsofthsm2.so \
++    /usr/lib/x86_64-linux-gnu/softhsm/libsofthsm2.so
++
+ #load private key
+-cmd='p11tool --provider /usr/lib64/pkcs11/libsofthsm2.so --write --load-privkey "$PRIVKEY" --label "$OBJNAME" --login --set-pin=1234 "pkcs11:token="$OBJNAME""'
++cmd="p11tool --provider $LIBSOFTHSM_PATH --write --load-privkey $PRIVKEY --label $OBJNAME --login --set-pin=1234 \"pkcs11:token=$OBJNAME\""
+ eval echo "$cmd"
+-out=$(eval $cmd)
++out=$(eval "$cmd")
+ ret=$?
+ if [ $ret -ne 0 ]; then
+    echo "Loading privkey failed"
+@@ -52,15 +71,15 @@ if [ $ret -ne 0 ]; then
+    exit 1
+ fi
+
+-cat $PUBKEY
++cat "$PUBKEY"
+
+-ls -l $TESTDIR
++ls -l "$TESTDIR"
+
+-if [ $LOADPUBLIC -ne 0 ]; then
++if [ "$LOADPUBLIC" -ne 0 ]; then
+ #load public key
+-    cmd='p11tool --provider /usr/lib64/pkcs11/libsofthsm2.so --write --load-pubkey "$PUBKEY" --label "$OBJNAME" --login --set-pin=1234 "pkcs11:token="$OBJNAME""'
++    cmd="p11tool --provider $LIBSOFTHSM_PATH --write --load-pubkey $PUBKEY --label $OBJNAME --login --set-pin=1234 \"pkcs11:token=$OBJNAME\""
+     eval echo "$cmd"
+-    out=$(eval $cmd)
++    out=$(eval "$cmd")
+     ret=$?
+     if [ $ret -ne 0 ]; then
+         echo "Loading pubkey failed"
+@@ -69,9 +88,9 @@ if [ $LOADPUBLIC -ne 0 ]; then
+     fi
+ fi
+
+-cmd='p11tool --list-all --login "pkcs11:token="$OBJNAME"" --set-pin=1234'
++cmd="p11tool --list-all --login \"pkcs11:token=$OBJNAME\" --set-pin=1234"
+ eval echo "$cmd"
+-out=$(eval $cmd)
++out=$(eval "$cmd")
+ ret=$?
+ if [ $ret -ne 0 ]; then
+     echo "Loging failed"

SOURCES/rekey_test_fixup.patch

@@ -0,0 +1,21 @@
+diff --color -ru ../libssh-0.10.4/tests/client/torture_rekey.c ./tests/client/torture_rekey.c
+--- ../libssh-0.10.4/tests/client/torture_rekey.c	2023-05-17 10:55:23.384684129 +0200
++++ ./tests/client/torture_rekey.c	2023-05-17 10:56:29.819334665 +0200
+@@ -504,7 +504,7 @@
+     memset(data, 'A', 128);
+     for (i = 0; i < KEX_RETRY; i++) {
+         ssh_send_ignore(s->ssh.session, data);
+-        ssh_handle_packets(s->ssh.session, 100);
++        ssh_handle_packets(s->ssh.session, 1000);
+ 
+         c = s->ssh.session->current_crypto;
+         /* SHA256 len */
+@@ -582,7 +582,7 @@
+     memset(data, 'A', 128);
+     for (i = 0; i < KEX_RETRY; i++) {
+         ssh_send_ignore(s->ssh.session, data);
+-        ssh_handle_packets(s->ssh.session, 100);
++        ssh_handle_packets(s->ssh.session, 1000);
+ 
+         c = s->ssh.session->current_crypto;
+         /* SHA256 len */

SPECS/libssh.spec

@@ -1,54 +1,58 @@
 Name:           libssh
-Version:        0.11.1
+Version:        0.10.4
-Release:        1%{?dist}
+Release:        12%{?dist}
 Summary:        A library implementing the SSH protocol
-License:        LGPL-2.1-or-later
+License:        LGPLv2+
 URL:            http://www.libssh.org
 
-Source0:        https://www.libssh.org/files/0.11/%{name}-%{version}.tar.xz
+Source0:        https://www.libssh.org/files/0.10/%{name}-%{version}.tar.xz
-Source1:        https://www.libssh.org/files/0.11/%{name}-%{version}.tar.xz.asc
+Source1:        https://www.libssh.org/files/0.10/%{name}-%{version}.tar.xz.asc
-Source2:        https://www.libssh.org/files/0x03D5DF8CFDD3E8E7_libssh_libssh_org_gpgkey.asc#/%{name}.keyring
+Source2:        https://cryptomilk.org/gpgkey-8DFF53E18F2ABC8D8F3C92237EE0FC4DCC014E3D.gpg#/%{name}.keyring
 Source3:        libssh_client.config
 Source4:        libssh_server.config
-# Don't use global openssl.cnf for PKCS#11 URI Tests
-# https://gitlab.com/libssh/libssh-mirror/-/merge_requests/543
-Patch1:         libssh-0.11.1-fix-provider-loading.patch
 
 BuildRequires:  cmake
 BuildRequires:  gcc-c++
 BuildRequires:  gnupg2
 BuildRequires:  openssl-devel
+BuildRequires:  openssl-pkcs11
 BuildRequires:  pkgconfig
 BuildRequires:  zlib-devel
 BuildRequires:  krb5-devel
-BuildRequires:  krb5-server
-BuildRequires:  krb5-workstation
 BuildRequires:  libcmocka-devel
 BuildRequires:  pam_wrapper
 BuildRequires:  socket_wrapper
 BuildRequires:  nss_wrapper
 BuildRequires:  uid_wrapper
-BuildRequires:  priv_wrapper
 BuildRequires:  openssh-clients
 BuildRequires:  openssh-server
 BuildRequires:  nmap-ncat
-BuildRequires:  pkcs11-provider
-BuildRequires:  p11-kit-devel
-BuildRequires:  p11-kit-server
-BuildRequires:  opensc
 BuildRequires:  softhsm
 BuildRequires:  gnutls-utils
 
 Requires:       %{name}-config = %{version}-%{release}
+Requires:       crypto-policies
 
-Recommends:     crypto-policies
+%ifarch aarch64 ppc64 ppc64le s390x x86_64
-
-%ifarch aarch64 ppc64 ppc64le s390x x86_64 riscv64
 Provides: libssh_threads.so.4()(64bit)
 %else
 Provides: libssh_threads.so.4
 %endif
 
+Patch1: coverity_scan.patch
+Patch2: pkcs11_test_fix.patch
+Patch3: loglevel.patch
+Patch4: plus_sign.patch
+Patch5: memory_leak.patch
+Patch6: options_apply.patch
+Patch7: enable_sk_keys_by_config.patch
+Patch8: null_dereference_rekey.patch
+Patch9: auth_bypass.patch
+Patch10: covscan23.patch
+Patch11: rekey_test_fixup.patch
+Patch12: covscan23_1.patch
+Patch13: CVE-2023-48795.patch
+
 %description
 The ssh library was designed to be used by programmers needing a working SSH
 implementation by the mean of a library. The complete control of the client is
@@ -60,7 +64,6 @@ third-party programs others than libcrypto (from openssl).
 %package devel
 Summary:        Development files for %{name}
 Requires:       %{name}%{?_isa} = %{version}-%{release}
-Requires:       cmake-filesystem
 
 %description devel
 The %{name}-devel package contains libraries and header files for developing
@@ -75,7 +78,7 @@ Obsoletes:      %{name} < 0.9.0-3
 The %{name}-config package provides the default configuration files for %{name}.
 
 %prep
-%{gpgverify} --keyring='%{SOURCE2}' --signature='%{SOURCE1}' --data='%{SOURCE0}'
+gpgv2 --quiet --keyring %{SOURCE2} %{SOURCE1} %{SOURCE0}
 %autosetup -p1
 
 %build
@@ -83,9 +86,7 @@ The %{name}-config package provides the default configuration files for %{name}.
     -DUNIT_TESTING=ON \
     -DCLIENT_TESTING=ON \
     -DSERVER_TESTING=ON \
-    -DGSSAPI_TESTING=ON \
     -DWITH_PKCS11_URI=ON \
-    -DWITH_PKCS11_PROVIDER=ON \
     -DGLOBAL_CLIENT_CONFIG="%{_sysconfdir}/libssh/libssh_client.config" \
     -DGLOBAL_BIND_CONFIG="%{_sysconfdir}/libssh/libssh_server.config"
 
@@ -130,6 +131,8 @@ popd
 
 %files devel
 %{_includedir}/libssh/
+# own this to avoid dep on cmake -- rex
+%dir  %{_libdir}/cmake/
 %{_libdir}/cmake/libssh/
 %{_libdir}/pkgconfig/libssh.pc
 %{_libdir}/libssh.so
@@ -141,86 +144,98 @@ popd
 %attr(0644,root,root) %config(noreplace) %{_sysconfdir}/libssh/libssh_server.config
 
 %changelog
-* Wed Oct 23 2024 Sahana Prasad <sahana@redhat.com> - 0.11.1-1
+* Mon Jan 15 2024 Sahana Prasad <sahana@redhat.com> - 0.10.4-12
-- Rebase to new upstream version 0.11.1
+- Fix CVE-2023-48795 Prefix truncation attack on Binary Packet Protocol (BPP)
-- Resolves: RHEL-64319
+- Resolves: RHEL-20939
-
+
-* Tue Aug 20 2024 Jakub Jelen <jjelen@redhat.com> - 0.10.6-8
+* Wed Jun 21 2023 Norbert Pocs <npocs@redhat.com> - 0.10.4-11
-- Remove the dependency on engine.h
+- Fix loglevel regression
-
+- Related: rhbz#2182252, rhbz#2189740
-* Mon Jun 24 2024 Troy Dawson <tdawson@redhat.com> - 0.10.6-7
+
-- Bump release for June 2024 mass rebuild
+* Mon May 22 2023 Norbert Pocs <npocs@redhat.com> - 0.10.4.10
-
+- Fix null dereference issues found by covscan
-* Fri Jun 07 2024 David Abdurachmanov <davidlt@rivosinc.com> - 0.10.6-6
+- Related: rhbz#2182252, rhbz#2189740
-- Add riscv64
+
-
+* Wed May 10 2023 Norbert Pocs <npocs@redhat.com> - 0.10.4-9
-* Wed May 22 2024 Sahana Prasad <sahana@redhat.com> - 0.10.6-5
+- Fix CVE-2023-1667 and CVE-2023-2283
-- Build libssh with pkcs11-provider instead of pkcs11 engine
+- Fix issues found by cosvcan
-- Resolves: RHEL-30437
+- Resolves: rhbz#2182252, rhbz#2189740
-
+
-* Thu Jan 25 2024 Fedora Release Engineering <releng@fedoraproject.org> - 0.10.6-4
+* Mon Jan 23 2023 Stanislav Zidek <szidek@redhat.com> - 0.10.4-8
-- Rebuilt for https://fedoraproject.org/wiki/Fedora_40_Mass_Rebuild
++ libssh-0.10.4-8
-
+- Extended CI to run internal tests in RHEL
-* Sun Jan 21 2024 Fedora Release Engineering <releng@fedoraproject.org> - 0.10.6-3
+- Related: rhbz#2160080
-- Rebuilt for https://fedoraproject.org/wiki/Fedora_40_Mass_Rebuild
+
-
+* Wed Jan 4 2023 Norbert Pocs <npocs@redhat.com> - 0.10.4-7
-* Fri Dec 22 2023 Jakub Jelen <jjelen@redhat.com> - 0.10.6-2
+- Add sk-keys to configuration parsing allowing to turn on-off by config
-- Fix regression in IPv6 hosntames parsing
+- Related: rhbz#2026449
-
+
-* Mon Dec 18 2023 Jakub Jelen <jjelen@redhat.com> - 0.10.6-1
+* Thu Dec 1 2022 Norbert Pocs <npocs@redhat.com> - 0.10.4-6
-- New upstream release fixing (CVE-2023-48795, CVE-2023-6004, CVE-2023-6918)
+- Fix covscan error
-
+- Remove unwanted test with yet unimplemented feature
-* Thu Jul 20 2023 Fedora Release Engineering <releng@fedoraproject.org> - 0.10.5-2
+- Related: rhbz#2137839, rhbz#2136824
-- Rebuilt for https://fedoraproject.org/wiki/Fedora_39_Mass_Rebuild
+
-
+* Thu Dec 01 2022 Stanislav Zidek <szidek@redhat.com> - 0.10.4-5
-* Fri May 05 2023 Orion Poplawski <orion@nwra.com> - 0.10.5-1
++ libssh-0.10.4-5
-- Update to 0.10.5 (CVE-2023-1667 CVE-2023-2283)
+- Fixed CI configuration due to TMT changes
-- Have libssh-devel require cmake-filesystem
+
-
+* Wed Nov 30 2022 Norbert Pocs <npocs@redhat.com> - 0.10.4-4
-* Sun Mar 05 2023 Andreas Schneider <asn@redhat.com> - 0.10.4-4
+- Move loglevel closer to openssh loglevel
-- Update License to SPDX expression
+- Add openssh config feature of +,-,^ for algorithm lists
-
+- Fix memory leaks of bignum
-* Thu Jan 19 2023 Fedora Release Engineering <releng@fedoraproject.org> - 0.10.4-3
+- Prevent multiple expansion of escape characters
-- Rebuilt for https://fedoraproject.org/wiki/Fedora_38_Mass_Rebuild
+- Resolves: rhbz#2132407, rhbz#2137839, rhbz#2144795, rhbz#2136824
-
+
-* Thu Oct 06 2022 Norbert Pocs <npocs@redhat.com> - 0.10.4-2
+* Tue Oct 4 2022 Norbert Pocs <npocs@redhat.com> - 0.10.4-3
 - Enable pkcs11 support
-
+- Fix broken libsofthsm path on i686
-* Wed Sep 07 2022 Andreas Schneider <asn@redhat.com> - 0.10.4-1
+- Add missing bugzilla references from the rebase commit
-- Update to version 0.10.4
+- Related: rhbz#2026449
-  https://git.libssh.org/projects/libssh.git/tag/?h=libssh-0.10.4
+- Resolves: rhbz#1977913, rhbz#1975500
-
+
-* Fri Sep 02 2022 Andreas Schneider <asn@redhat.com> - 0.10.3-1
+* Tue Sep 27 2022 Norbert Pocs <npocs@redhat.com> - 0.10.4-2
-- Update to version 0.10.3
+- Fix coverity scan issues
-  https://git.libssh.org/projects/libssh.git/tag/?h=libssh-0.10.3
+- Resolves: rhbz#2130126
-  https://git.libssh.org/projects/libssh.git/tag/?h=libssh-0.10.2
+
-  https://git.libssh.org/projects/libssh.git/tag/?h=libssh-0.10.1
+* Mon Sep 19 2022 Norbert pocs <npocs@redhat.com> - 0.10.4-1
-  https://git.libssh.org/projects/libssh.git/tag/?h=libssh-0.10.0
+- Rebase to version 0.10.4
-- Removed libssh-0.9.6-openssh-8.8p1-compat.patch
+- Add pkcs11 support
-- resolves: rhbz#2121741
+- Disallow ssh-rsa key in FIPS mode
-
+- Fix openssl KDF check at build
-* Thu Jul 21 2022 Fedora Release Engineering <releng@fedoraproject.org> - 0.9.6-5
+- ChangeLog was renamed to CHANGELOG
-- Rebuilt for https://fedoraproject.org/wiki/Fedora_37_Mass_Rebuild
+- Resolves: rhbz#2068475, rhbz#2026449, rhbz#2004021,
-
+            rhbz#1977913, rhbz#1975500
-* Fri Jan 28 2022 Jakub Jelen <jjelen@redhat.com> - 0.9.6-4
+
-- Fix build-time tests to work with OpenSSH 8.8p1
+* Fri Nov 12 2021 Stanislav Zidek <szidek@redhat.com> - 0.9.6-3
-
++ libssh-0.9.6-3
-* Thu Jan 20 2022 Fedora Release Engineering <releng@fedoraproject.org> - 0.9.6-3
+- Disabled gating on osci.brew-build.revdeps.integration
-- Rebuilt for https://fedoraproject.org/wiki/Fedora_36_Mass_Rebuild
+  Related: rhbz#2022034
-
+
-* Mon Jan 10 2022 Stephen Gallagher <sgallagh@redhat.com> - 0.9.6-2
+* Thu Nov 11 2021 Stanislav Zidek <szidek@redhat.com> - 0.9.6-2
-- Skip broken torture_auth tests
+- STI, FMF, and gating fixes
-
+  Resolves: rhbz#2022034
-* Wed Sep 15 2021 Norbert Pocs <npocs@redhat.com> - 0.9.6-1
+
+* Tue Oct 05 2021 Norbert Pocs <npocs@redhat.com> - 0.9.6-1
 - Fix CVE-CVE-2021-3634 libssh: possible heap-based buffer
   overflow when rekeying
-- Resolves: rhbz#1994600
+- Fix static analyzer issues in rhbz#1938795
+- Rebase to version 0.9.6
+- Resolves: rhbz#1994607, rhbz#1938795, rhbz#2009669
+
+* Mon Aug 09 2021 Mohan Boddu <mboddu@redhat.com> - 0.9.5-6
+- Rebuilt for IMA sigs, glibc 2.34, aarch64 flags
+  Related: rhbz#1991688
+
+* Wed Jun 16 2021 Mohan Boddu <mboddu@redhat.com> - 0.9.5-5
+- Rebuilt for RHEL 9 BETA for openssl 3.0
+  Related: rhbz#1971065
 
-* Tue Sep 14 2021 Sahana Prasad <sahana@redhat.com> - 0.9.5-4
+* Tue Apr 27 2021 Sahana Prasad <sahana@redhat.com> - 0.9.5-4
-- Rebuilt with OpenSSL 3.0.0
+- Change crypto-policies from recommends to requires
+  Resolves: rhbz#1947863
 
-* Thu Jul 22 2021 Fedora Release Engineering <releng@fedoraproject.org> - 0.9.5-3
+* Fri Apr 16 2021 Mohan Boddu <mboddu@redhat.com> - 0.9.5-3
-- Rebuilt for https://fedoraproject.org/wiki/Fedora_35_Mass_Rebuild
+- Rebuilt for RHEL 9 BETA on Apr 15th 2021. Related: rhbz#1947937
 
 * Tue Jan 26 2021 Fedora Release Engineering <releng@fedoraproject.org> - 0.9.5-2
 - Rebuilt for https://fedoraproject.org/wiki/Fedora_34_Mass_Rebuild