5 files changed, 302 insertions, 13 deletions

diff --git a/regress/unittests/sshbuf/test_sshbuf_getput_basic.c b/regress/unittests/sshbuf/test_sshbuf_getput_basic.c
index 966e8432b..bea89881a 100644
--- a/regress/unittests/sshbuf/test_sshbuf_getput_basic.c
+++ b/regress/unittests/sshbuf/test_sshbuf_getput_basic.c
@@ -1,4 +1,4 @@
-/*      $OpenBSD: test_sshbuf_getput_basic.c,v 1.1 2014/04/30 05:32:00 djm Exp $ */
+/*      $OpenBSD: test_sshbuf_getput_basic.c,v 1.2 2019/07/14 23:33:19 djm Exp $ */
 /*
  * Regress test for sshbuf.h buffer API
  *
@@ -481,4 +481,233 @@ sshbuf_getput_basic_tests(void)
         ASSERT_MEM_EQ(sshbuf_ptr(p1), bn_exp3, sizeof(bn_exp3));
         sshbuf_free(p1);
         TEST_DONE();
+
+        TEST_START("sshbuf_peek_u64");
+        p1 = sshbuf_new();
+        ASSERT_PTR_NE(p1, NULL);
+        ASSERT_INT_EQ(sshbuf_put(p1, x, sizeof(x)), 0);
+        ASSERT_INT_EQ(sshbuf_peek_u64(p1, 0, &v64), 0);
+        ASSERT_U64_EQ(v64, 0x1122334455667788ULL);
+        ASSERT_INT_EQ(sshbuf_peek_u64(p1, 2, &v64), 0);
+        ASSERT_U64_EQ(v64, 0x3344556677880099ULL);
+        ASSERT_INT_EQ(sshbuf_peek_u64(p1, 3, &v64), SSH_ERR_MESSAGE_INCOMPLETE);
+        ASSERT_INT_EQ(sshbuf_peek_u64(p1, sizeof(x), &v64),
+            SSH_ERR_MESSAGE_INCOMPLETE);
+        ASSERT_INT_EQ(sshbuf_peek_u64(p1, 1000, &v64),
+            SSH_ERR_MESSAGE_INCOMPLETE);
+        sshbuf_free(p1);
+        TEST_DONE();
+
+        TEST_START("sshbuf_peek_u32");
+        p1 = sshbuf_new();
+        ASSERT_PTR_NE(p1, NULL);
+        ASSERT_INT_EQ(sshbuf_put(p1, x, sizeof(x)), 0);
+        ASSERT_INT_EQ(sshbuf_peek_u32(p1, 0, &v32), 0);
+        ASSERT_U32_EQ(v32, 0x11223344);
+        ASSERT_INT_EQ(sshbuf_peek_u32(p1, 6, &v32), 0);
+        ASSERT_U32_EQ(v32, 0x77880099);
+        ASSERT_INT_EQ(sshbuf_peek_u32(p1, 7, &v32), SSH_ERR_MESSAGE_INCOMPLETE);
+        ASSERT_INT_EQ(sshbuf_peek_u32(p1, sizeof(x), &v32),
+            SSH_ERR_MESSAGE_INCOMPLETE);
+        ASSERT_INT_EQ(sshbuf_peek_u32(p1, 1000, &v32),
+            SSH_ERR_MESSAGE_INCOMPLETE);
+        sshbuf_free(p1);
+        TEST_DONE();
+
+        TEST_START("sshbuf_peek_u16");
+        p1 = sshbuf_new();
+        ASSERT_PTR_NE(p1, NULL);
+        ASSERT_INT_EQ(sshbuf_put(p1, x, sizeof(x)), 0);
+        ASSERT_INT_EQ(sshbuf_peek_u16(p1, 0, &v16), 0);
+        ASSERT_U16_EQ(v16, 0x1122);
+        ASSERT_INT_EQ(sshbuf_peek_u16(p1, 8, &v16), 0);
+        ASSERT_U16_EQ(v16, 0x99);
+        ASSERT_INT_EQ(sshbuf_peek_u16(p1, 9, &v16), SSH_ERR_MESSAGE_INCOMPLETE);
+        ASSERT_INT_EQ(sshbuf_peek_u16(p1, sizeof(x), &v16),
+            SSH_ERR_MESSAGE_INCOMPLETE);
+        ASSERT_INT_EQ(sshbuf_peek_u16(p1, 1000, &v16),
+            SSH_ERR_MESSAGE_INCOMPLETE);
+        sshbuf_free(p1);
+        TEST_DONE();
+
+        TEST_START("sshbuf_peek_u8");
+        p1 = sshbuf_new();
+        ASSERT_PTR_NE(p1, NULL);
+        ASSERT_INT_EQ(sshbuf_put(p1, x, sizeof(x)), 0);
+        ASSERT_INT_EQ(sshbuf_peek_u8(p1, 0, &v8), 0);
+        ASSERT_U8_EQ(v8, 0x11);
+        ASSERT_INT_EQ(sshbuf_peek_u8(p1, 9, &v8), 0);
+        ASSERT_U8_EQ(v8, 0x99);
+        ASSERT_INT_EQ(sshbuf_peek_u8(p1, sizeof(x), &v8),
+            SSH_ERR_MESSAGE_INCOMPLETE);
+        ASSERT_INT_EQ(sshbuf_peek_u8(p1, 1000, &v8),
+            SSH_ERR_MESSAGE_INCOMPLETE);
+        sshbuf_free(p1);
+        TEST_DONE();
+
+        TEST_START("sshbuf_poke_u64");
+        p1 = sshbuf_new();
+        ASSERT_PTR_NE(p1, NULL);
+        ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
+        /* poke at start of buffer */
+        ASSERT_INT_EQ(sshbuf_poke_u64(p1, 0, 0xa1b2c3d4e5f60718ULL), 0);
+        s2 = sshbuf_dtob16(p1);
+        ASSERT_PTR_NE(s2, NULL);
+        ASSERT_STRING_EQ(s2, "a1b2c3d4e5f607180000");
+        free(s2);
+        sshbuf_reset(p1);
+        ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
+        /* poke aligned with end of buffer */
+        ASSERT_INT_EQ(sshbuf_poke_u64(p1, 2, 0xa1b2c3d4e5f60718ULL), 0);
+        s2 = sshbuf_dtob16(p1);
+        ASSERT_PTR_NE(s2, NULL);
+        ASSERT_STRING_EQ(s2, "0000a1b2c3d4e5f60718");
+        free(s2);
+        sshbuf_reset(p1);
+        ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
+        /* poke past end of buffer */
+        ASSERT_INT_EQ(sshbuf_poke_u64(p1, 3, 0xa1b2c3d4e5f60718ULL),
+            SSH_ERR_NO_BUFFER_SPACE);
+        ASSERT_INT_EQ(sshbuf_poke_u64(p1, 10, 0xa1b2c3d4e5f60718ULL),
+            SSH_ERR_NO_BUFFER_SPACE);
+        ASSERT_INT_EQ(sshbuf_poke_u64(p1, 1000, 0xa1b2c3d4e5f60718ULL),
+            SSH_ERR_NO_BUFFER_SPACE);
+        /* ensure failed pokes do not modify buffer */
+        s2 = sshbuf_dtob16(p1);
+        ASSERT_PTR_NE(s2, NULL);
+        ASSERT_STRING_EQ(s2, "00000000000000000000");
+        sshbuf_free(p1);
+        TEST_DONE();
+
+        TEST_START("sshbuf_poke_u32");
+        p1 = sshbuf_new();
+        ASSERT_PTR_NE(p1, NULL);
+        ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
+        /* poke at start of buffer */
+        ASSERT_INT_EQ(sshbuf_poke_u32(p1, 0, 0xa1b2c3d4), 0);
+        s2 = sshbuf_dtob16(p1);
+        ASSERT_PTR_NE(s2, NULL);
+        ASSERT_STRING_EQ(s2, "a1b2c3d4000000000000");
+        free(s2);
+        sshbuf_reset(p1);
+        ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
+        /* poke aligned with end of buffer */
+        ASSERT_INT_EQ(sshbuf_poke_u32(p1, 6, 0xa1b2c3d4), 0);
+        s2 = sshbuf_dtob16(p1);
+        ASSERT_PTR_NE(s2, NULL);
+        ASSERT_STRING_EQ(s2, "000000000000a1b2c3d4");
+        free(s2);
+        sshbuf_reset(p1);
+        ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
+        /* poke past end of buffer */
+        ASSERT_INT_EQ(sshbuf_poke_u32(p1, 7, 0xa1b2c3d4),
+            SSH_ERR_NO_BUFFER_SPACE);
+        ASSERT_INT_EQ(sshbuf_poke_u32(p1, 10, 0xa1b2c3d4),
+            SSH_ERR_NO_BUFFER_SPACE);
+        ASSERT_INT_EQ(sshbuf_poke_u32(p1, 1000, 0xa1b2c3d4),
+            SSH_ERR_NO_BUFFER_SPACE);
+        /* ensure failed pokes do not modify buffer */
+        s2 = sshbuf_dtob16(p1);
+        ASSERT_PTR_NE(s2, NULL);
+        ASSERT_STRING_EQ(s2, "00000000000000000000");
+        sshbuf_free(p1);
+        TEST_DONE();
+
+        TEST_START("sshbuf_poke_u16");
+        p1 = sshbuf_new();
+        ASSERT_PTR_NE(p1, NULL);
+        ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
+        /* poke at start of buffer */
+        ASSERT_INT_EQ(sshbuf_poke_u16(p1, 0, 0xa1b2), 0);
+        s2 = sshbuf_dtob16(p1);
+        ASSERT_PTR_NE(s2, NULL);
+        ASSERT_STRING_EQ(s2, "a1b20000000000000000");
+        free(s2);
+        sshbuf_reset(p1);
+        ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
+        /* poke aligned with end of buffer */
+        ASSERT_INT_EQ(sshbuf_poke_u16(p1, 8, 0xa1b2), 0);
+        s2 = sshbuf_dtob16(p1);
+        ASSERT_PTR_NE(s2, NULL);
+        ASSERT_STRING_EQ(s2, "0000000000000000a1b2");
+        free(s2);
+        sshbuf_reset(p1);
+        ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
+        /* poke past end of buffer */
+        ASSERT_INT_EQ(sshbuf_poke_u16(p1, 9, 0xa1b2),
+            SSH_ERR_NO_BUFFER_SPACE);
+        ASSERT_INT_EQ(sshbuf_poke_u16(p1, 10, 0xa1b2),
+            SSH_ERR_NO_BUFFER_SPACE);
+        ASSERT_INT_EQ(sshbuf_poke_u16(p1, 1000, 0xa1b2),
+            SSH_ERR_NO_BUFFER_SPACE);
+        /* ensure failed pokes do not modify buffer */
+        s2 = sshbuf_dtob16(p1);
+        ASSERT_PTR_NE(s2, NULL);
+        ASSERT_STRING_EQ(s2, "00000000000000000000");
+        sshbuf_free(p1);
+        TEST_DONE();
+
+        TEST_START("sshbuf_poke_u8");
+        p1 = sshbuf_new();
+        ASSERT_PTR_NE(p1, NULL);
+        ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
+        /* poke at start of buffer */
+        ASSERT_INT_EQ(sshbuf_poke_u8(p1, 0, 0xa1), 0);
+        s2 = sshbuf_dtob16(p1);
+        ASSERT_PTR_NE(s2, NULL);
+        ASSERT_STRING_EQ(s2, "a1000000000000000000");
+        free(s2);
+        sshbuf_reset(p1);
+        ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
+        /* poke aligned with end of buffer */
+        ASSERT_INT_EQ(sshbuf_poke_u8(p1, 9, 0xa1), 0);
+        s2 = sshbuf_dtob16(p1);
+        ASSERT_PTR_NE(s2, NULL);
+        ASSERT_STRING_EQ(s2, "000000000000000000a1");
+        free(s2);
+        sshbuf_reset(p1);
+        ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
+        /* poke past end of buffer */
+        ASSERT_INT_EQ(sshbuf_poke_u8(p1, 10, 0xa1), SSH_ERR_NO_BUFFER_SPACE);
+        ASSERT_INT_EQ(sshbuf_poke_u8(p1, 1000, 0xa1), SSH_ERR_NO_BUFFER_SPACE);
+        /* ensure failed pokes do not modify buffer */
+        s2 = sshbuf_dtob16(p1);
+        ASSERT_PTR_NE(s2, NULL);
+        ASSERT_STRING_EQ(s2, "00000000000000000000");
+        sshbuf_free(p1);
+        TEST_DONE();
+
+        TEST_START("sshbuf_poke");
+        p1 = sshbuf_new();
+        ASSERT_PTR_NE(p1, NULL);
+        ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
+        /* poke at start of buffer */
+        ASSERT_INT_EQ(sshbuf_poke(p1, 0, "hello!", 6), 0);
+        s2 = sshbuf_dtob16(p1);
+        ASSERT_PTR_NE(s2, NULL);
+        ASSERT_STRING_EQ(s2, "68656c6c6f2100000000");
+        free(s2);
+        sshbuf_reset(p1);
+        ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
+        /* poke aligned with end of buffer */
+        ASSERT_INT_EQ(sshbuf_poke(p1, 4, "hello!", 6), 0);
+        s2 = sshbuf_dtob16(p1);
+        ASSERT_PTR_NE(s2, NULL);
+        ASSERT_STRING_EQ(s2, "0000000068656c6c6f21");
+        free(s2);
+        sshbuf_reset(p1);
+        ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
+        /* poke past end of buffer */
+        ASSERT_INT_EQ(sshbuf_poke(p1, 7, "hello!", 6),
+            SSH_ERR_NO_BUFFER_SPACE);
+        ASSERT_INT_EQ(sshbuf_poke(p1, 10, "hello!", 6),
+            SSH_ERR_NO_BUFFER_SPACE);
+        ASSERT_INT_EQ(sshbuf_poke(p1, 1000, "hello!", 6),
+            SSH_ERR_NO_BUFFER_SPACE);
+        /* ensure failed pokes do not modify buffer */
+        s2 = sshbuf_dtob16(p1);
+        ASSERT_PTR_NE(s2, NULL);
+        ASSERT_STRING_EQ(s2, "00000000000000000000");
+        sshbuf_free(p1);
+        TEST_DONE();
 }
diff --git a/regress/unittests/sshbuf/test_sshbuf_getput_crypto.c b/regress/unittests/sshbuf/test_sshbuf_getput_crypto.c
index 5d39e63e1..492b3bdf0 100644
--- a/regress/unittests/sshbuf/test_sshbuf_getput_crypto.c
+++ b/regress/unittests/sshbuf/test_sshbuf_getput_crypto.c
@@ -7,6 +7,8 @@
 
 #include "includes.h"
 
+#ifdef WITH_OPENSSL
+
 #include <sys/types.h>
 #include <sys/param.h>
 #include <stdio.h>
@@ -276,3 +278,4 @@ sshbuf_getput_crypto_tests(void)
 #endif
 }
 
+#endif /* WITH_OPENSSL */
diff --git a/regress/unittests/sshbuf/test_sshbuf_getput_fuzz.c b/regress/unittests/sshbuf/test_sshbuf_getput_fuzz.c
index ca06bfb00..1ca30be97 100644
--- a/regress/unittests/sshbuf/test_sshbuf_getput_fuzz.c
+++ b/regress/unittests/sshbuf/test_sshbuf_getput_fuzz.c
@@ -32,10 +32,12 @@ static void
 attempt_parse_blob(u_char *blob, size_t len)
 {
         struct sshbuf *p1;
+#ifdef WITH_OPENSSL
         BIGNUM *bn;
 #if defined(OPENSSL_HAS_ECC) && defined(OPENSSL_HAS_NISTP256)
         EC_KEY *eck;
-#endif
+#endif /* defined(OPENSSL_HAS_ECC) && defined(OPENSSL_HAS_NISTP256) */
+#endif /* WITH_OPENSSL */
         u_char *s;
         size_t l;
         u_int8_t u8;
@@ -54,6 +56,7 @@ attempt_parse_blob(u_char *blob, size_t len)
                 bzero(s, l);
                 free(s);
         }
+#ifdef WITH_OPENSSL
         bn = NULL;
         sshbuf_get_bignum2(p1, &bn);
         BN_clear_free(bn);
@@ -62,7 +65,8 @@ attempt_parse_blob(u_char *blob, size_t len)
         ASSERT_PTR_NE(eck, NULL);
         sshbuf_get_eckey(p1, eck);
         EC_KEY_free(eck);
-#endif
+#endif /* defined(OPENSSL_HAS_ECC) && defined(OPENSSL_HAS_NISTP256) */
+#endif /* WITH_OPENSSL */
         sshbuf_free(p1);
 }
 
diff --git a/regress/unittests/sshbuf/test_sshbuf_misc.c b/regress/unittests/sshbuf/test_sshbuf_misc.c
index 762a6c31c..c53db937f 100644
--- a/regress/unittests/sshbuf/test_sshbuf_misc.c
+++ b/regress/unittests/sshbuf/test_sshbuf_misc.c
@@ -1,4 +1,4 @@
-/*      $OpenBSD: test_sshbuf_misc.c,v 1.2 2016/05/03 13:48:33 djm Exp $ */
+/*      $OpenBSD: test_sshbuf_misc.c,v 1.4 2019/07/16 22:16:49 djm Exp $ */
 /*
  * Regress test for sshbuf.h buffer API
  *
@@ -19,6 +19,7 @@
 #include "../test_helper/test_helper.h"
 
 #include "sshbuf.h"
+#include "ssherr.h"
 
 void sshbuf_misc_tests(void);
 
@@ -26,7 +27,7 @@ void
 sshbuf_misc_tests(void)
 {
         struct sshbuf *p1;
-        char tmp[512], *p;
+        char tmp[512], msg[] = "imploring ping silence ping over", *p;
         FILE *out;
         size_t sz;
 
@@ -60,48 +61,48 @@ sshbuf_misc_tests(void)
         sshbuf_free(p1);
         TEST_DONE();
 
-        TEST_START("sshbuf_dtob64 len 1");
+        TEST_START("sshbuf_dtob64_string len 1");
         p1 = sshbuf_new();
         ASSERT_PTR_NE(p1, NULL);
         ASSERT_INT_EQ(sshbuf_put_u8(p1, 0x11), 0);
-        p = sshbuf_dtob64(p1);
+        p = sshbuf_dtob64_string(p1, 0);
         ASSERT_PTR_NE(p, NULL);
         ASSERT_STRING_EQ(p, "EQ==");
         free(p);
         sshbuf_free(p1);
         TEST_DONE();
 
-        TEST_START("sshbuf_dtob64 len 2");
+        TEST_START("sshbuf_dtob64_string len 2");
         p1 = sshbuf_new();
         ASSERT_PTR_NE(p1, NULL);
         ASSERT_INT_EQ(sshbuf_put_u8(p1, 0x11), 0);
         ASSERT_INT_EQ(sshbuf_put_u8(p1, 0x22), 0);
-        p = sshbuf_dtob64(p1);
+        p = sshbuf_dtob64_string(p1, 0);
         ASSERT_PTR_NE(p, NULL);
         ASSERT_STRING_EQ(p, "ESI=");
         free(p);
         sshbuf_free(p1);
         TEST_DONE();
 
-        TEST_START("sshbuf_dtob64 len 3");
+        TEST_START("sshbuf_dtob64_string len 3");
         p1 = sshbuf_new();
         ASSERT_PTR_NE(p1, NULL);
         ASSERT_INT_EQ(sshbuf_put_u8(p1, 0x11), 0);
         ASSERT_INT_EQ(sshbuf_put_u8(p1, 0x22), 0);
         ASSERT_INT_EQ(sshbuf_put_u8(p1, 0x33), 0);
-        p = sshbuf_dtob64(p1);
+        p = sshbuf_dtob64_string(p1, 0);
         ASSERT_PTR_NE(p, NULL);
         ASSERT_STRING_EQ(p, "ESIz");
         free(p);
         sshbuf_free(p1);
         TEST_DONE();
 
-        TEST_START("sshbuf_dtob64 len 8191");
+        TEST_START("sshbuf_dtob64_string len 8191");
         p1 = sshbuf_new();
         ASSERT_PTR_NE(p1, NULL);
         ASSERT_INT_EQ(sshbuf_reserve(p1, 8192, NULL), 0);
         bzero(sshbuf_mutable_ptr(p1), 8192);
-        p = sshbuf_dtob64(p1);
+        p = sshbuf_dtob64_string(p1, 0);
         ASSERT_PTR_NE(p, NULL);
         ASSERT_SIZE_T_EQ(strlen(p), ((8191 + 2) / 3) * 4);
         free(p);
@@ -163,5 +164,55 @@ sshbuf_misc_tests(void)
         ASSERT_PTR_EQ(p, NULL);
         sshbuf_free(p1);
         TEST_DONE();
+
+        TEST_START("sshbuf_cmp");
+        p1 = sshbuf_from(msg, sizeof(msg) - 1);
+        ASSERT_PTR_NE(p1, NULL);
+        ASSERT_INT_EQ(sshbuf_cmp(p1, 0, "i", 1), 0);
+        ASSERT_INT_EQ(sshbuf_cmp(p1, 0, "j", 1), SSH_ERR_INVALID_FORMAT);
+        ASSERT_INT_EQ(sshbuf_cmp(p1, 0, "imploring", 9), 0);
+        ASSERT_INT_EQ(sshbuf_cmp(p1, 0, "implored", 9), SSH_ERR_INVALID_FORMAT);
+        ASSERT_INT_EQ(sshbuf_cmp(p1, 10, "ping", 4), 0);
+        ASSERT_INT_EQ(sshbuf_cmp(p1, 10, "ring", 4), SSH_ERR_INVALID_FORMAT);
+        ASSERT_INT_EQ(sshbuf_cmp(p1, 28, "over", 4), 0);
+        ASSERT_INT_EQ(sshbuf_cmp(p1, 28, "rove", 4), SSH_ERR_INVALID_FORMAT);
+        ASSERT_INT_EQ(sshbuf_cmp(p1, 28, "overt", 5),
+            SSH_ERR_MESSAGE_INCOMPLETE);
+        ASSERT_INT_EQ(sshbuf_cmp(p1, 32, "ping", 4),
+            SSH_ERR_MESSAGE_INCOMPLETE);
+        ASSERT_INT_EQ(sshbuf_cmp(p1, 1000, "silence", 7),
+            SSH_ERR_MESSAGE_INCOMPLETE);
+        ASSERT_INT_EQ(sshbuf_cmp(p1, 0, msg, sizeof(msg) - 1), 0);
+        TEST_DONE();
+
+        TEST_START("sshbuf_find");
+        p1 = sshbuf_from(msg, sizeof(msg) - 1);
+        ASSERT_PTR_NE(p1, NULL);
+        ASSERT_INT_EQ(sshbuf_find(p1, 0, "i", 1, &sz), 0);
+        ASSERT_SIZE_T_EQ(sz, 0);
+        ASSERT_INT_EQ(sshbuf_find(p1, 0, "j", 1, &sz), SSH_ERR_INVALID_FORMAT);
+        ASSERT_INT_EQ(sshbuf_find(p1, 0, "imploring", 9, &sz), 0);
+        ASSERT_SIZE_T_EQ(sz, 0);
+        ASSERT_INT_EQ(sshbuf_find(p1, 0, "implored", 9, &sz),
+            SSH_ERR_INVALID_FORMAT);
+        ASSERT_INT_EQ(sshbuf_find(p1, 3, "ping", 4, &sz), 0);
+        ASSERT_SIZE_T_EQ(sz, 10);
+        ASSERT_INT_EQ(sshbuf_find(p1, 11, "ping", 4, &sz), 0);
+        ASSERT_SIZE_T_EQ(sz, 23);
+        ASSERT_INT_EQ(sshbuf_find(p1, 20, "over", 4, &sz), 0);
+        ASSERT_SIZE_T_EQ(sz, 28);
+        ASSERT_INT_EQ(sshbuf_find(p1, 28, "over", 4, &sz), 0);
+        ASSERT_SIZE_T_EQ(sz, 28);
+        ASSERT_INT_EQ(sshbuf_find(p1, 28, "rove", 4, &sz),
+            SSH_ERR_INVALID_FORMAT);
+        ASSERT_INT_EQ(sshbuf_find(p1, 28, "overt", 5, &sz),
+            SSH_ERR_MESSAGE_INCOMPLETE);
+        ASSERT_INT_EQ(sshbuf_find(p1, 32, "ping", 4, &sz),
+            SSH_ERR_MESSAGE_INCOMPLETE);
+        ASSERT_INT_EQ(sshbuf_find(p1, 1000, "silence", 7, &sz),
+            SSH_ERR_MESSAGE_INCOMPLETE);
+        ASSERT_INT_EQ(sshbuf_find(p1, 0, msg + 1, sizeof(msg) - 2, &sz), 0);
+        ASSERT_SIZE_T_EQ(sz, 1);
+        TEST_DONE();
 }
 
diff --git a/regress/unittests/sshbuf/tests.c b/regress/unittests/sshbuf/tests.c
index 1557e4342..29916a10b 100644
--- a/regress/unittests/sshbuf/tests.c
+++ b/regress/unittests/sshbuf/tests.c
@@ -20,7 +20,9 @@ tests(void)
 {
         sshbuf_tests();
         sshbuf_getput_basic_tests();
+#ifdef WITH_OPENSSL
         sshbuf_getput_crypto_tests();
+#endif
         sshbuf_misc_tests();
         sshbuf_fuzz_tests();
         sshbuf_getput_fuzz_tests();