@zerodensity/smb-cpp 0.0.0-bootstrap.0 → 0.1.0

package/win32_x64/third-party/libsmb2/source/libsmb2.pc.in

@@ -0,0 +1,14 @@
+# libsmb2 pkg-config file
+
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: libsmb2
+Description: libsmb2 is a client library for accessing SMB shares over a network.
+Version: @VERSION@
+Requires:
+Conflicts:
+Libs: -L${libdir} -lsmb2
+Cflags: -I${includedir}

package/win32_x64/third-party/libsmb2/source/packaging/RPM/libsmb2.spec.in

@@ -0,0 +1,135 @@
+Name: libsmb2
+Summary: SMB2/3 client library
+Vendor: Ronnie Sahlberg
+Packager: ronniesahlberg@gmail.com
+Version: @VERSION@
+Release: 1
+Epoch: 0
+License: GNU LGPL version 2.1
+Group: System Environment/Libraries
+URL: http://www.github.com/sahlberg/libsmb2
+
+Source: libsmb2-%{version}.tar.gz
+
+Provides: lib = %{version}
+
+Prefix: /usr
+BuildRoot: %{_tmppath}/%{name}-%{version}-root
+
+%description
+Libsmb2 is a SMB2/3 client library
+
+#######################################################################
+
+
+
+%prep
+%setup -q
+# setup the init script and sysconfig file
+%setup -T -D -n libsmb2-%{version} -q
+
+%build
+
+## check for ccache
+if ccache -h >/dev/null 2>&1 ; then
+	CC="ccache gcc"
+else
+	CC="gcc"
+fi
+
+export CC
+
+## always run autogen.sh
+aclocal
+autoheader
+autoconf
+libtoolize -c -f -i
+automake --add-missing
+
+
+CFLAGS="$RPM_OPT_FLAGS $EXTRA -O2 -D_GNU_SOURCE" %configure
+
+%install
+# Clean up in case there is trash left from a previous build
+rm -rf $RPM_BUILD_ROOT
+
+# Create the target build directory hierarchy
+
+make DESTDIR=$RPM_BUILD_ROOT install
+
+# Remove "*.old" files
+find $RPM_BUILD_ROOT -name "*.old" -exec rm -f {} \;
+
+%clean
+rm -rf $RPM_BUILD_ROOT
+
+
+#######################################################################
+## Files section                                                     ##
+#######################################################################
+
+%files
+%defattr(-,root,root)
+
+%{_libdir}/libsmb2.so*
+
+%package devel
+Summary: Development libraries for LibSMB2
+Group: Development
+
+%description devel
+development libraries for LibSMB2
+
+%files devel
+%defattr(-,root,root)
+%{_includedir}/smb2/libsmb2.h
+%{_includedir}/smb2/libsmb2-raw.h
+%{_includedir}/smb2/libsmb2-dcerpc.h
+%{_includedir}/smb2/libsmb2-dcerpc-lsa.h
+%{_includedir}/smb2/libsmb2-dcerpc-srvsvc.h
+%{_includedir}/smb2/smb2.h
+%{_includedir}/smb2/smb2-errors.h
+%{_libdir}/libsmb2.a
+%{_libdir}/pkgconfig/libsmb2.pc
+
+%changelog
+* Mon Dec 16 2024 : Version 6.1.0
+ - Fix return code for smb2-ls on failure
+ - Fix memory errors in smb2_opendir()
+ - Add a macro te test for the version of the share-enum api
+* Wed Dec 11 2024 : Version 6.0.0
+ - Major rewrites to DCE-RPC
+ - Initial support for building servers
+* Mon Jan 17 2022 : Version 4.0.0
+ - Add support for SMB3 encryption
+ - Add support for Anonymous NTLMSSP logins
+ - Add support for readlink.
+ - Add API to notify application of changes to which filehandles are used by
+ libsmb2.
+ - Add support for Big Endian DCERPC and allow it to be controlled from the
+ URL.
+ - Add support for 3.1.1 signing
+ - Add support for PS2(EE) and PS3
+ - Fixes to UCS2 when compose characters are used.
+ 
+ - Various MacOS fixes
+ - Fix a few NULL dereferences
+* Mon Jun 10 2019 : Version 3.0.0
+ - ESP32 support
+ - Support specifying the port number in an SMB URL.
+ - Add creation time to smb_stat
+ - Abort all commands when the context is destroyed.
+ - Free all file and directory handles when the context is destroyed.
+ - Fix handling of O_TRUNC
+ - Add more error codes.
+ - Add support for SMB2_IOCTL
+ - Handle DCE/RPC fragment reassembly for IOCTL().
+* Sat Jul 7 2018 : Version 2.0.0
+ - SMB2/3 signing
+ - Kerberos authentication
+ - Builtin NTLMSSP authentication for when libkrb5 is not available
+ - Share enumeration
+ - CMake support
+ - Various bugfixes
+* Sun Mar 5 2017 : Version 1.0.0
+ - Initial version

package/win32_x64/third-party/libsmb2/source/packaging/RPM/makerpms.sh

@@ -0,0 +1,114 @@
+#!/bin/sh
+#
+# makerpms.sh  -  build RPM packages from the git sources
+#
+# Copyright (C) John H Terpstra 1998-2002
+# Copyright (C) Gerald (Jerry) Carter 2003
+# Copyright (C) Jim McDonough 2007
+# Copyright (C) Andrew Tridgell 2007
+# Copyright (C) Michael Adam 2008-2009
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the Free
+# Software Foundation; either version 3 of the License, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, see <http://www.gnu.org/licenses/>.
+#
+
+#
+# The following allows environment variables to override the target directories
+#   the alternative is to have a file in your home directory called .rpmmacros
+#   containing the following:
+#   %_topdir  /home/mylogin/redhat
+#
+# Note: Under this directory rpm expects to find the same directories that are under the
+#   /usr/src/redhat directory
+#
+
+EXTRA_OPTIONS="$1"
+
+DIRNAME=$(dirname $0)
+TOPDIR=${DIRNAME}/../..
+
+SPECDIR=`rpm --eval %_specdir`
+SRCDIR=`rpm --eval %_sourcedir`
+
+SPECFILE="libsmb2.spec"
+SPECFILE_IN="libsmb2.spec.in"
+RPMBUILD="rpmbuild"
+
+# We use tags and determine the version, as follows:
+# libsmb2-0.9.1  (First release of 0.9).
+# libsmb2-0.9.23 (23rd minor release of the 112 version)
+#
+# If we're not directly on a tag, this is a devel release; we append
+# .0.<patchnum>.<checksum>.devel to the release.
+TAG=`git describe`
+case "$TAG" in
+    libsmb2-*)
+	TAG=${TAG##libsmb2-}
+	case "$TAG" in
+	    *-*-g*) # 0.9-168-ge6cf0e8
+		# Not exactly on tag: devel version.
+		VERSION=`echo "$TAG" | sed 's/\([^-]\+\)-\([0-9]\+\)-\(g[0-9a-f]\+\)/\1.0.\2.\3.devel/'`
+		;;
+	    *)
+		# An actual release version
+		VERSION=$TAG
+		;;
+	esac
+	;;
+    *)
+	echo Invalid tag "$TAG" >&2
+	exit 1
+	;;
+esac
+
+sed -e s/@VERSION@/$VERSION/g \
+	< ${DIRNAME}/${SPECFILE_IN} \
+	> ${DIRNAME}/${SPECFILE}
+
+VERSION=$(grep ^Version ${DIRNAME}/${SPECFILE} | sed -e 's/^Version:\ \+//')
+
+if echo | gzip -c --rsyncable - > /dev/null 2>&1 ; then
+	GZIP="gzip -9 --rsyncable"
+else
+	GZIP="gzip -9"
+fi
+
+pushd ${TOPDIR}
+echo -n "Creating libsmb2-${VERSION}.tar.gz ... "
+mkdir -p "${SRCDIR}"
+git archive --prefix=libsmb2-${VERSION}/ HEAD | ${GZIP} > ${SRCDIR}/libsmb2-${VERSION}.tar.gz
+RC=$?
+popd
+echo "Done."
+if [ $RC -ne 0 ]; then
+        echo "Build failed!"
+        exit 1
+fi
+
+# At this point the SPECDIR and SRCDIR variables must have a value!
+
+##
+## copy additional source files
+##
+mkdir -p ${SPECDIR}
+cp -p ${DIRNAME}/${SPECFILE} ${SPECDIR}
+
+##
+## Build
+##
+echo "$(basename $0): Getting Ready to build release package"
+${RPMBUILD} -ba --clean --rmsource ${EXTRA_OPTIONS} ${SPECDIR}/${SPECFILE} || exit 1
+
+echo "$(basename $0): Done."
+
+exit 0

package/win32_x64/third-party/libsmb2/source/tests/Makefile.am

@@ -0,0 +1,34 @@
+AM_CPPFLAGS = -I${srcdir}/../include -I${srcdir}/../include/smb2 \
+	"-D_U_=__attribute__((unused))" \
+	"-D_R_(A,B)=__attribute__((format(printf,A,B)))"
+AM_CFLAGS = $(WARN_CFLAGS)
+LDADD = ../lib/libsmb2.la
+
+noinst_PROGRAMS = prog_ls prog_mkdir prog_rmdir prog_cat \
+	prog_cat_cancel smb2-dcerpc-coder-test
+noinst_PROGRAMS += metastat-0202-censored
+
+EXTRA_PROGRAMS = ld_sockerr
+CLEANFILES = ld_sockerr.o ld_sockerr.so
+
+ld_sockerr_SOURCES = ld_sockerr.c
+ld_sockerr_CFLAGS = $(AM_CFLAGS) -fPIC
+
+bin_SCRIPTS = ld_sockerr.so
+
+ld_sockerr.o: ld_sockerr-ld_sockerr.o
+	$(LIBTOOL) --mode=link $(CC) -o $@ $^
+
+ld_sockerr.so: ld_sockerr.o
+	$(CC) -shared -o ld_sockerr.so ld_sockerr.o -ldl
+
+T = `ls test_*.sh`
+
+test: $(noinst_PROGRAMS) $(bin_SCRIPTS)
+	for TEST in $(T); do \
+		echo "Running $$TEST"; \
+		echo "--------------"; \
+		sh $$TEST || exit 1; \
+		echo "--------------"; \
+		echo; \
+	done

package/win32_x64/third-party/libsmb2/source/tests/README

@@ -0,0 +1,28 @@
+To run the test you need an SMB server that exports a share and
+two configurations files:
+
+1, ./tests/NTLM
+===============
+This file contains the username to password mapping you need to authenticate
+to the server with NTLM.
+
+Example:
+$ cat tests/NTLM
+win16-1:Administrator:mypassword
+$
+
+2, tests/setup.local
+====================
+This file sets two environment variables the tests need, NTLM_USER_FILE
+and TESTURL.
+
+Example:
+$ cat tests/setup.local
+TESTURL=smb://Administrator@win16-1/Share
+NTLM_USER_FILE=`pwd`/NTLM
+$
+
+A good idea is to use a special share/subdirectory on the server
+so that the tests do not overwrite/corrupt/delete important files.
+Create a dedicated share on the server that is only used for testing
+and be prepared that any data in this share can be randomly deleted.

package/win32_x64/third-party/libsmb2/source/tests/aes128ccm-test.c

@@ -0,0 +1,119 @@
+/* -*-  mode:c; tab-width:8; c-basic-offset:8; indent-tabs-mode:nil;  -*- */
+#include <arpa/inet.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "lib/aes128ccm.h"
+
+void test_1(void)
+{
+  unsigned char key[16]  = {0x40, 0x41, 0x42, 0x43,  0x44, 0x45, 0x46, 0x47,
+			    0x48, 0x49, 0x4a, 0x4b,  0x4c, 0x4d, 0x4e, 0x4f};
+  unsigned char nonce[7] = {0x10, 0x11, 0x12, 0x13,  0x14, 0x15, 0x16 };
+  unsigned char aad[8]   = {0x00, 0x01, 0x02, 0x03,  0x04, 0x05, 0x06, 0x07};
+  unsigned char p[4]     = {0x20, 0x21, 0x22, 0x23};
+  int mlen = 4;
+  unsigned char exp[8]   = {0x71, 0x62, 0x01, 0x5b, 0x4d, 0xac, 0x25, 0x5d};
+
+  unsigned char buf[1024];
+  int i, rc;
+
+  memcpy(buf, p, sizeof(p));
+
+  aes128ccm_encrypt(key,
+                    nonce, sizeof(nonce),
+                    aad, sizeof(aad),
+                    buf, sizeof(p),
+                    &buf[sizeof(p)], mlen);
+  printf("Expected:\n");
+  for (i = 0; i < sizeof(p) + mlen; i++) {
+          printf("%02x ", exp[i]);
+  }
+  printf("\n");
+  printf("Got:\n");
+  for (i = 0; i < sizeof(p) + mlen; i++) {
+          printf("%02x ", buf[i]);
+  }
+  printf("\n");
+
+  rc = aes128ccm_decrypt(key,
+                         nonce, sizeof(nonce),
+                         aad, sizeof(aad),
+                         buf, sizeof(p),
+                         &buf[sizeof(p)], mlen);
+  
+  printf("it ran rc : %d\n", rc);
+  if (rc) exit(10);
+  printf("Got:\n");
+  for (i = 0; i < sizeof(p); i++) {
+          printf("%02x ", buf[i]);
+  }
+  printf("\n");
+
+  printf("Decrypted correct: %d\n", memcmp(p, &buf[0], sizeof(p)));
+  if (memcmp(p, &buf[0], sizeof(p))) exit(10);
+}
+
+void test_2(void)
+{
+  unsigned char key[16]  = {0x40, 0x41, 0x42, 0x43,  0x44, 0x45, 0x46, 0x47,
+			    0x48, 0x49, 0x4a, 0x4b,  0x4c, 0x4d, 0x4e, 0x4f};
+  unsigned char nonce[] = {0x10, 0x11, 0x12, 0x13,  0x14, 0x15, 0x16, 0x17,
+                            0x18, 0x19, 0x1a, 0x1b};
+  unsigned char aad[]   = {0x00, 0x01, 0x02, 0x03,  0x04, 0x05, 0x06, 0x07,
+                            0x08, 0x09, 0x0a, 0x0b,  0x0c, 0x0d, 0x0e, 0x0f,
+                            0x10, 0x11, 0x12, 0x13};
+  unsigned char p[]     = {0x20, 0x21, 0x22, 0x23,  0x24, 0x25, 0x26, 0x27,
+                            0x28, 0x29, 0x2a, 0x2b,  0x2c, 0x2d, 0x2e, 0x2f,
+                            0x30, 0x31, 0x32, 0x33,  0x34, 0x35, 0x36, 0x37};
+  int mlen = 8;
+  unsigned char exp[]   = {0xe3, 0xb2, 0x01, 0xa9,  0xf5, 0xb7, 0x1a, 0x7a,
+                           0x9b, 0x1c, 0xea, 0xec,  0xcd, 0x97, 0xe7, 0x0b,
+                           0x61, 0x76, 0xaa, 0xd9,  0xa4, 0x42, 0x8a, 0xa5,
+                           0x48, 0x43, 0x92, 0xfb,  0xc1, 0xb0, 0x99, 0x51};
+  unsigned char buf[1024];
+  int i, rc;
+
+  memcpy(buf, p, sizeof(p));
+
+  aes128ccm_encrypt(key,
+                    nonce, sizeof(nonce),
+                    aad, sizeof(aad),
+                    buf, sizeof(p),
+                    &buf[sizeof(p)], mlen);
+  printf("Expected:\n");
+  for (i = 0; i < sizeof(p) + mlen; i++) {
+          printf("%02x ", exp[i]);
+  }
+  printf("\n");
+  printf("Got:\n");
+  for (i = 0; i < sizeof(p) + mlen; i++) {
+          printf("%02x ", buf[i]);
+  }
+  printf("\n");
+  rc = aes128ccm_decrypt(key,
+                         nonce, sizeof(nonce),
+                         aad, sizeof(aad),
+                         buf, sizeof(p),
+                         &buf[sizeof(p)], mlen);
+  
+  printf("it ran rc : %d\n", rc);
+  if (rc) exit(10);
+  printf("Got:\n");
+  for (i = 0; i < sizeof(p); i++) {
+          printf("%02x ", buf[i]);
+  }
+  printf("\n");
+
+  printf("Decrypted correct: %d\n", memcmp(p, &buf[0], sizeof(p)));
+  if (memcmp(p, &buf[0], sizeof(p))) exit(10);
+}
+
+int main(int argc, char *argv[])
+{
+        test_1();
+        test_2();
+        return 0;
+}

package/win32_x64/third-party/libsmb2/source/tests/functions.sh

@@ -0,0 +1,11 @@
+. ./setup.local
+
+success() {
+    echo "[OK]"
+}
+
+failure() {
+    echo "[FAILED]"
+    exit 1
+}
+

package/win32_x64/third-party/libsmb2/source/tests/ld_sockerr.c

@@ -0,0 +1,58 @@
+/* -*-  mode:c; tab-width:8; c-basic-offset:8; indent-tabs-mode:nil;  -*- */
+/*
+   Copyright (C) 2024 by Ronnie Sahlberg <ronniesahlberg@gmail.com>
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, see <http://www.gnu.org/licenses/>.
+*/
+
+#define _GNU_SOURCE
+
+#include <asm/fcntl.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <sys/uio.h>
+#include <unistd.h>
+
+#include <sys/syscall.h>
+#include <dlfcn.h>
+
+int readv_close = -1;
+
+ssize_t readv(int fd, const struct iovec *iov, int iovcnt)
+{
+        static int call_idx = 0;
+        static int (*real_readv)(int fd, const struct iovec *iov, int iovcnt) = NULL;
+
+        if (real_readv == NULL) {
+                real_readv = dlsym(RTLD_NEXT, "readv");
+                
+                /* Close the socket at this call to readv */
+                if (getenv("READV_CLOSE") != NULL) {
+                        readv_close = atoi(getenv("READV_CLOSE"));
+                }
+        }
+        
+        call_idx++;
+
+        if (call_idx == readv_close) {
+                /* write some garbage */
+                write(fd, &call_idx, sizeof(call_idx));
+                errno = EBADF;
+                return -1;
+        }
+        return real_readv(fd, iov, iovcnt);
+}
+

package/win32_x64/third-party/libsmb2/source/tests/metastat-0202-censored.c

@@ -0,0 +1,136 @@
+// metastat.c — queue multiple SMB2 STATs in parallel on one connection
+#define _GNU_SOURCE
+#include <errno.h>
+#include <poll.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include <smb2/smb2.h>
+#include <smb2/libsmb2.h>
+
+struct op {
+    const char *path;          // relative path under share (or URL path + filename)
+    struct smb2_stat_64 st;    // result buffer filled by libsmb2
+    int status;                // 0 = OK from callback
+};
+
+struct cbwrap {
+    struct op *op;
+    int *pending;              // shared counter
+};
+
+static void stat_cb(struct smb2_context *ctx, int status, void *cmd_data, void *cb_data) {
+    (void)ctx; (void)cmd_data;
+    struct cbwrap *w = (struct cbwrap *)cb_data;
+    w->op->status = status;
+    if (w->pending) (*w->pending)--;
+    free(w);
+}
+
+static int service_loop(struct smb2_context *ctx, int *pending) {
+    while (*pending > 0) {
+        struct pollfd pfd = { .fd = smb2_get_fd(ctx), .events = smb2_which_events(ctx) };
+        int ret = poll(&pfd, 1, 1000);
+        if (ret < 0) { perror("poll"); return -1; }
+        if (ret == 0) continue;
+        if (smb2_service(ctx, pfd.revents) < 0) {
+            fprintf(stderr, "smb2_service: %s\n", smb2_get_error(ctx));
+            return -1;
+        }
+    }
+    return 0;
+}
+
+static void usage(const char *prog) {
+    fprintf(stderr,
+        "Usage: %s [-p PASSWORD] smb://[domain;][user@]server/share[/base][?args] file1 [file2 ...]\n",
+        prog);
+}
+
+int main(int argc, char **argv) {
+    const char *password = NULL;
+    int opt;
+    while ((opt = getopt(argc, argv, "p:")) != -1) {
+        if (opt == 'p') password = optarg;
+        else { usage(argv[0]); return 2; }
+    }
+    if (optind >= argc || optind == argc-1) { usage(argv[0]); return 2; }
+
+    const char *urlstr = argv[optind++];
+    int nfiles = argc - optind;
+
+    struct smb2_context *ctx = smb2_init_context();
+    if (!ctx) { fprintf(stderr, "smb2_init_context failed\n"); return 1; }
+
+    struct smb2_url *url = smb2_parse_url(ctx, urlstr);
+    if (!url) { fprintf(stderr, "parse_url: %s\n", smb2_get_error(ctx)); return 1; }
+
+    if (url->user)   smb2_set_user(ctx, url->user);
+    if (url->domain) smb2_set_domain(ctx, url->domain);
+    if (password)    smb2_set_password(ctx, password);
+    smb2_set_version(ctx, SMB2_VERSION_0202);
+
+    // One connection/session to the share
+    if (smb2_connect_share(ctx, url->server, url->share, url->user) != 0) {
+        fprintf(stderr, "connect_share: %s\n", smb2_get_error(ctx));
+        return 1;
+    }
+
+    // Queue parallel STATs
+    int pending = 0;
+    for (int i = 0; i < nfiles; i++) {
+        const char *name = argv[optind + i];
+        char rel[4096];
+
+        if (url->path && *url->path)
+            snprintf(rel, sizeof rel, "%s/%s", url->path, name);
+        else
+            snprintf(rel, sizeof rel, "%s", name);
+
+        struct op *op = calloc(1, sizeof *op);
+        if (!op) { perror("calloc"); return 1; }
+        op->path = name;
+
+        struct cbwrap *w = malloc(sizeof *w);
+        if (!w) { perror("malloc"); free(op); return 1; }
+        w->op = op;
+        w->pending = &pending;
+
+        // NOTE: third arg is the OUT buffer where libsmb2 writes results
+        if (smb2_stat_async(ctx, rel, &op->st, stat_cb, w) != 0) {
+            fprintf(stderr, "smb2_stat_async(%s): %s\n", rel, smb2_get_error(ctx));
+            free(w); free(op);
+            continue;
+        }
+        pending++;
+
+        // stash pointer to 'op' for later printing (re-use argv slot)
+        *((struct op **)&argv[optind + i]) = op;
+    }
+
+    if (service_loop(ctx, &pending) < 0) return 1;
+
+    // Results
+    for (int i = 0; i < nfiles; i++) {
+        struct op *op = *((struct op **)&argv[optind + i]);
+        if (!op) continue;
+        if (op->status != 0) {
+            fprintf(stderr, "%s : error %d\n", op->path, op->status);
+        } else {
+            printf("%-40s size=%llu  mtime=%lld  isdir=%d\n",
+                   op->path,
+                   (unsigned long long)op->st.smb2_size,
+                   (long long)op->st.smb2_mtime,
+                   (op->st.smb2_type == SMB2_TYPE_DIRECTORY));
+        }
+        free(op);
+    }
+
+    smb2_destroy_url(url);
+    smb2_destroy_context(ctx);
+    return 0;
+}