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

package/darwin_arm64/third-party/libsmb2/source/lib/hmac-md5.c

@@ -0,0 +1,84 @@
+/* From RFC2104 */
+
+/*
+** Function: hmac_md5
+*/
+#ifdef HAVE_STRINGS_H
+#include <strings.h>
+#endif
+
+#include "compat.h"
+
+#include "md5.h"
+
+/*
+ * unsigned char*  text;                pointer to data stream/
+ * int             text_len;            length of data stream
+ * unsigned char*  key;                 pointer to authentication key
+ * int             key_len;             length of authentication key
+ * caddr_t         digest;              caller digest to be filled in
+ */
+void
+smb2_hmac_md5(unsigned char *text, int text_len, unsigned char *key, unsigned int key_len,
+	 unsigned char *digest)
+{
+        struct MD5Context context;
+        unsigned char k_ipad[65];    /* inner padding -
+                                      * key XORd with ipad
+                                      */
+        unsigned char k_opad[65];    /* outer padding -
+                                      * key XORd with opad
+                                      */
+        unsigned char tk[16];
+        int i;
+        /* if key is longer than 64 bytes reset it to key=MD5(key) */
+        if (key_len > 64) {
+		struct MD5Context tctx;
+
+                MD5Init(&tctx);
+                MD5Update(&tctx, key, key_len);
+                MD5Final(tk, &tctx);
+
+                key = tk;
+                key_len = 16;
+        }
+
+        /*
+         * the HMAC_MD5 transform looks like:
+         *
+         * MD5(K XOR opad, MD5(K XOR ipad, text))
+         *
+         * where K is an n byte key
+         * ipad is the byte 0x36 repeated 64 times
+         * and text is the data being protected
+         */
+
+        /* start out by storing key in pads */
+        memset(k_ipad, 0, sizeof k_ipad);
+        memset(k_opad, 0, sizeof k_opad);
+        memmove(k_ipad, key, key_len);
+        memmove(k_opad, key, key_len);
+
+        /* XOR key with ipad and opad values */
+        for (i=0; i<64; i++) {
+                k_ipad[i] ^= 0x36;
+                k_opad[i] ^= 0x5c;
+        }
+        /*
+         * perform inner MD5
+         */
+        MD5Init(&context);                   /* init context for 1st
+                                              * pass */
+        MD5Update(&context, k_ipad, 64);     /* start with inner pad */
+        MD5Update(&context, text, text_len); /* then text of datagram */
+        MD5Final(digest, &context);          /* finish up 1st pass */
+        /*
+         * perform outer MD5
+         */
+        MD5Init(&context);                   /* init context for 2nd
+                                              * pass */
+        MD5Update(&context, k_opad, 64);     /* start with outer pad */
+        MD5Update(&context, digest, 16);     /* then results of 1st
+                                              * hash */
+        MD5Final(digest, &context);          /* finish up 2nd pass */
+}

package/darwin_arm64/third-party/libsmb2/source/lib/hmac-md5.h

@@ -0,0 +1,42 @@
+/* From RFC1204  HMAC-MD5
+ */
+
+#ifndef HMAC_MD5_H
+#define HMAC_MD5_H
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <string.h>
+#include <sys/types.h>
+
+#ifdef HAVE_STDINT_H
+#include <stdint.h>
+#endif
+
+#if (__BYTE_ORDER == __BIG_ENDIAN) || defined(XBOX_360_PLATFORM)
+#  define WORDS_BIGENDIAN 1
+#endif
+
+#if !defined(__PS2__) && !defined(PICO_PLATFORM)
+#ifndef UWORD32_DEFINED
+#define UWORD32_DEFINED
+typedef uint32_t UWORD32;
+#endif
+
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void
+smb2_hmac_md5(unsigned char *text, int text_len, unsigned char *key, unsigned int key_len,
+	 unsigned char *digest);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !HMAC_MD5_H */

package/darwin_arm64/third-party/libsmb2/source/lib/hmac.c

@@ -0,0 +1,245 @@
+/**************************** hmac.c ****************************/
+/******************** See RFC 4634 for details ******************/
+/*
+ *  Description:
+ *      This file implements the HMAC algorithm (Keyed-Hashing for
+ *      Message Authentication, RFC2104), expressed in terms of the
+ *      various SHA algorithms.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_STDINT_H
+#include <stdint.h>
+#endif
+
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#include "compat.h"
+
+#include "sha.h"
+
+/*
+ *  hmac
+ *
+ *  Description:
+ *      This function will compute an HMAC message digest.
+ *
+ *  Parameters:
+ *      whichSha: [in]
+ *          One of SHA1, SHA224, SHA256, SHA384, SHA512
+ *      key: [in]
+ *          The secret shared key.
+ *      key_len: [in]
+ *          The length of the secret shared key.
+ *      message_array: [in]
+ *          An array of characters representing the message.
+ *      length: [in]
+ *          The length of the message in message_array
+ *      digest: [out]
+ *          Where the digest is returned.
+ *          NOTE: The length of the digest is determined by
+ *              the value of whichSha.
+ *
+ *  Returns:
+ *      sha Error Code.
+ *
+ */
+int
+hmac (SHAversion whichSha, const unsigned char *text, size_t text_len,
+      const unsigned char *key, size_t key_len, uint8_t digest[USHAMaxHashSize])
+{
+  HMACContext ctx;
+  return hmacReset (&ctx, whichSha, key, key_len) ||
+    hmacInput (&ctx, text, text_len) || hmacResult (&ctx, digest);
+}
+
+/*
+ *  hmacReset
+ *
+ *  Description:
+ *      This function will initialize the hmacContext in preparation
+ *      for computing a new HMAC message digest.
+ *
+ *  Parameters:
+ *      context: [in/out]
+ *          The context to reset.
+ *      whichSha: [in]
+ *          One of SHA1, SHA224, SHA256, SHA384, SHA512
+ *      key: [in]
+ *          The secret shared key.
+ *      key_len: [in]
+ *          The length of the secret shared key.
+ *
+ *  Returns:
+ *      sha Error Code.
+ *
+ */
+int
+hmacReset (HMACContext * ctx, enum SHAversion whichSha,
+	   const unsigned char *key, size_t key_len)
+{
+  int i, blocksize, hashsize;
+
+  /* inner padding - key XORd with ipad */
+  unsigned char k_ipad[USHA_Max_Message_Block_Size];
+
+  /* temporary buffer when keylen > blocksize */
+  unsigned char tempkey[USHAMaxHashSize];
+
+  if (!ctx)
+    return shaNull;
+
+  blocksize = ctx->blockSize = USHABlockSize (whichSha);
+  hashsize = ctx->hashSize = USHAHashSize (whichSha);
+
+  ctx->whichSha = whichSha;
+
+  /*
+   * If key is longer than the hash blocksize,
+   * reset it to key = HASH(key).
+   */
+  if (key_len > (size_t)blocksize)
+    {
+      USHAContext tctx;
+      int err = USHAReset (&tctx, whichSha) ||
+	USHAInput (&tctx, key, key_len) || USHAResult (&tctx, tempkey);
+      if (err != shaSuccess)
+	return err;
+
+      key = tempkey;
+      key_len = hashsize;
+    }
+
+  /*
+   * The HMAC transform looks like:
+   *
+   * SHA(K XOR opad, SHA(K XOR ipad, text))
+   *
+   * where K is an n byte key.
+   * ipad is the byte 0x36 repeated blocksize times
+   * opad is the byte 0x5c repeated blocksize times
+   * and text is the data being protected.
+   */
+
+  /* store key into the pads, XOR'd with ipad and opad values */
+  for (i = 0; i < (int)key_len; i++)
+    {
+      k_ipad[i] = key[i] ^ 0x36;
+      ctx->k_opad[i] = key[i] ^ 0x5c;
+    }
+  /* remaining pad bytes are '\0' XOR'd with ipad and opad values */
+  for (; i < blocksize; i++)
+    {
+      k_ipad[i] = 0x36;
+      ctx->k_opad[i] = 0x5c;
+    }
+
+  /* perform inner hash */
+  /* init context for 1st pass */
+  return USHAReset (&ctx->shaContext, whichSha) ||
+    /* and start with inner pad */
+    USHAInput (&ctx->shaContext, k_ipad, blocksize);
+}
+
+/*
+ *  hmacInput
+ *
+ *  Description:
+ *      This function accepts an array of octets as the next portion
+ *      of the message.
+ *
+ *  Parameters:
+ *      context: [in/out]
+ *          The HMAC context to update
+ *      message_array: [in]
+ *          An array of characters representing the next portion of
+ *          the message.
+ *      length: [in]
+ *          The length of the message in message_array
+ *
+ *  Returns:
+ *      sha Error Code.
+ *
+ */
+int
+hmacInput (HMACContext * ctx, const unsigned char *text, size_t text_len)
+{
+  if (!ctx)
+    return shaNull;
+  /* then text of datagram */
+  return USHAInput (&ctx->shaContext, text, text_len);
+}
+
+/*
+ * HMACFinalBits
+ *
+ * Description:
+ *   This function will add in any final bits of the message.
+ *
+ * Parameters:
+ *   context: [in/out]
+ *     The HMAC context to update
+ *   message_bits: [in]
+ *     The final bits of the message, in the upper portion of the
+ *     byte. (Use 0b###00000 instead of 0b00000### to input the
+ *     three bits ###.)
+ *   length: [in]
+ *     The number of bits in message_bits, between 1 and 7.
+ *
+ * Returns:
+ *   sha Error Code.
+ */
+int
+hmacFinalBits (HMACContext * ctx, const uint8_t bits, size_t bitcount)
+{
+  if (!ctx)
+    return shaNull;
+  /* then final bits of datagram */
+  return USHAFinalBits (&ctx->shaContext, bits, bitcount);
+}
+
+/*
+ * HMACResult
+ *
+ * Description:
+ *   This function will return the N-byte message digest into the
+ *   Message_Digest array provided by the caller.
+ *   NOTE: The first octet of hash is stored in the 0th element,
+ *      the last octet of hash in the Nth element.
+ *
+ * Parameters:
+ *   context: [in/out]
+ *     The context to use to calculate the HMAC hash.
+ *   digest: [out]
+ *     Where the digest is returned.
+ *   NOTE 2: The length of the hash is determined by the value of
+ *      whichSha that was passed to hmacReset().
+ *
+ * Returns:
+ *   sha Error Code.
+ *
+ */
+int
+hmacResult (HMACContext * ctx, uint8_t * digest)
+{
+  if (!ctx)
+    return shaNull;
+
+  /* finish up 1st pass */
+  /* (Use digest here as a temporary buffer.) */
+  return USHAResult (&ctx->shaContext, digest) ||
+    /* perform outer SHA */
+    /* init context for 2nd pass */
+    USHAReset (&ctx->shaContext, ctx->whichSha) ||
+    /* start with outer pad */
+    USHAInput (&ctx->shaContext, ctx->k_opad, ctx->blockSize) ||
+    /* then results of 1st hash */
+    USHAInput (&ctx->shaContext, digest, ctx->hashSize) ||
+    /* finish up 2nd pass */
+    USHAResult (&ctx->shaContext, digest);
+}