Merge esp32 v7.2.0

configs/devices/xtensa-softmmu/default.mak

@@ -7,3 +7,4 @@ CONFIG_SEMIHOSTING=y
 CONFIG_XTENSA_SIM=y
 CONFIG_XTENSA_VIRT=y
 CONFIG_XTENSA_XTFPGA=y
+CONFIG_XTENSA_ESP32=y

crypto/meson.build

@@ -50,6 +50,10 @@ crypto_ss.add(when: gnutls, if_true: files('tls-cipher-suites.c'))
 
 util_ss.add(files('sm4.c'))
 util_ss.add(files('aes.c'))
+util_ss.add(files('sha512-internal.c'))
+util_ss.add(files('sha384-internal.c'))
+util_ss.add(files('sha256-internal.c'))
+util_ss.add(files('sha1-internal.c'))
 util_ss.add(files('init.c'))
 if gnutls.found()
   util_ss.add(gnutls)

crypto/sha1-internal.c

@@ -0,0 +1,227 @@
+/*
+ * SHA1 hash implementation and interface functions
+ * Copyright (c) 2003-2005, Jouni Malinen <j@w1.fi>
+ *
+ * This software may be distributed under the terms of the BSD license.
+ * See README for more details.
+ */
+
+#include "sha1_i.h"
+#include "stddef.h"
+#include "string.h"
+
+typedef struct sha1_state SHA1_CTX;
+
+/* ===== start - public domain SHA1 implementation ===== */
+
+/*
+ * SHA-1 in C
+ * By Steve Reid <sreid@sea-to-sky.net>
+ * 100% Public Domain
+ *
+ * -----------------
+ * Modified 7/98
+ * By James H. Brown <jbrown@burgoyne.com>
+ * Still 100% Public Domain
+ *
+ * Corrected a problem which generated improper hash values on 16 bit machines
+ * Routine SHA1Update changed from
+ *     void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned int
+ * len)
+ * to
+ *     void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned
+ * long len)
+ *
+ * The 'len' parameter was declared an int which works fine on 32 bit machines.
+ * However, on 16 bit machines an int is too small for the shifts being done
+ * against
+ * it.  This caused the hash function to generate incorrect values if len was
+ * greater than 8191 (8K - 1) due to the 'len << 3' on line 3 of SHA1Update().
+ *
+ * Since the file IO in main() reads 16K at a time, any file 8K or larger would
+ * be guaranteed to generate the wrong hash (e.g. Test Vector #3, a million
+ * "a"s).
+ *
+ * I also changed the declaration of variables i & j in SHA1Update to
+ * unsigned long from unsigned int for the same reason.
+ *
+ * These changes should make no difference to any 32 bit implementations since
+ * an
+ * int and a long are the same size in those environments.
+ *
+ * --
+ * I also corrected a few compiler warnings generated by Borland C.
+ * 1. Added #include <process.h> for exit() prototype
+ * 2. Removed unused variable 'j' in SHA1Final
+ * 3. Changed exit(0) to return(0) at end of main.
+ *
+ * ALL changes I made can be located by searching for comments containing 'JHB'
+ * -----------------
+ * Modified 8/98
+ * By Steve Reid <sreid@sea-to-sky.net>
+ * Still 100% public domain
+ *
+ * 1- Removed #include <process.h> and used return() instead of exit()
+ * 2- Fixed overwriting of finalcount in SHA1Final() (discovered by Chris Hall)
+ * 3- Changed email address from steve@edmweb.com to sreid@sea-to-sky.net
+ *
+ * -----------------
+ * Modified 4/01
+ * By Saul Kravitz <Saul.Kravitz@celera.com>
+ * Still 100% PD
+ * Modified to run on Compaq Alpha hardware.
+ *
+ * -----------------
+ * Modified 4/01
+ * By Jouni Malinen <j@w1.fi>
+ * Minor changes to match the coding style used in Dynamics.
+ *
+ * Modified September 24, 2004
+ * By Jouni Malinen <j@w1.fi>
+ * Fixed alignment issue in SHA1Transform when SHA1HANDSOFF is defined.
+ *
+ */
+
+/*
+ * Test Vectors (from FIPS PUB 180-1)
+ * "abc"
+ * A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
+ * "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
+ * 84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
+ * A million repetitions of "a"
+ * 34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
+ */
+
+#define SHA1HANDSOFF
+
+#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
+
+/* blk0() and blk() perform the initial expand. */
+/* I got the idea of expanding during the round function from SSLeay */
+#ifndef WORDS_BIGENDIAN
+#define blk0(i) (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \
+    (rol(block->l[i], 8) & 0x00FF00FF))
+#else
+#define blk0(i) (block->l[i])
+#endif
+#define blk(i) (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ \
+    block->l[(i + 8) & 15] ^ block->l[(i + 2) & 15] ^ block->l[i & 15], 1))
+
+/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
+#define R0(v, w, x, y, z, i) \
+    do { \
+        z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \
+        w = rol(w, 30); \
+    } while (0)
+#define R1(v, w, x, y, z, i) \
+    do { \
+        z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \
+        w = rol(w, 30); \
+    } while (0)
+#define R2(v, w, x, y, z, i) \
+    do { \
+        z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \
+        w = rol(w, 30); \
+    } while (0)
+#define R3(v, w, x, y, z, i) \
+    do { \
+        z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \
+        w = rol(w, 30); \
+    } while (0)
+#define R4(v, w, x, y, z, i) \
+    do { \
+        z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \
+        w = rol(w, 30); \
+    } while (0)
+
+/* Hash a single 512-bit block. This is the core of the algorithm. */
+
+void sha1_compress(uint32_t state[5], const unsigned char buffer[64])
+{
+    uint32_t a, b, c, d, e;
+    typedef union {
+        unsigned char c[64];
+        uint32_t l[16];
+    } CHAR64LONG16;
+    CHAR64LONG16 *block;
+#ifdef SHA1HANDSOFF
+    CHAR64LONG16 workspace;
+    block = &workspace;
+    memcpy(block, buffer, 64);
+#else
+    block = (CHAR64LONG16 *) buffer;
+#endif
+    /* Copy context->state[] to working vars */
+    a = state[0];
+    b = state[1];
+    c = state[2];
+    d = state[3];
+    e = state[4];
+    /* 4 rounds of 20 operations each. Loop unrolled. */
+    R0(a, b, c, d, e, 0); R0(e, a, b, c, d, 1);
+    R0(d, e, a, b, c, 2); R0(c, d, e, a, b, 3);
+    R0(b, c, d, e, a, 4); R0(a, b, c, d, e, 5);
+    R0(e, a, b, c, d, 6); R0(d, e, a, b, c, 7);
+    R0(c, d, e, a, b, 8); R0(b, c, d, e, a, 9);
+    R0(a, b, c, d, e, 10); R0(e, a, b, c, d, 11);
+    R0(d, e, a, b, c, 12); R0(c, d, e, a, b, 13);
+    R0(b, c, d, e, a, 14); R0(a, b, c, d, e, 15);
+    R1(e, a, b, c, d, 16); R1(d, e, a, b, c, 17);
+    R1(c, d, e, a, b, 18); R1(b, c, d, e, a, 19);
+    R2(a, b, c, d, e, 20); R2(e, a, b, c, d, 21);
+    R2(d, e, a, b, c, 22); R2(c, d, e, a, b, 23);
+    R2(b, c, d, e, a, 24); R2(a, b, c, d, e, 25);
+    R2(e, a, b, c, d, 26); R2(d, e, a, b, c, 27);
+    R2(c, d, e, a, b, 28); R2(b, c, d, e, a, 29);
+    R2(a, b, c, d, e, 30); R2(e, a, b, c, d, 31);
+    R2(d, e, a, b, c, 32); R2(c, d, e, a, b, 33);
+    R2(b, c, d, e, a, 34); R2(a, b, c, d, e, 35);
+    R2(e, a, b, c, d, 36); R2(d, e, a, b, c, 37);
+    R2(c, d, e, a, b, 38); R2(b, c, d, e, a, 39);
+    R3(a, b, c, d, e, 40); R3(e, a, b, c, d, 41);
+    R3(d, e, a, b, c, 42); R3(c, d, e, a, b, 43);
+    R3(b, c, d, e, a, 44); R3(a, b, c, d, e, 45);
+    R3(e, a, b, c, d, 46); R3(d, e, a, b, c, 47);
+    R3(c, d, e, a, b, 48); R3(b, c, d, e, a, 49);
+    R3(a, b, c, d, e, 50); R3(e, a, b, c, d, 51);
+    R3(d, e, a, b, c, 52); R3(c, d, e, a, b, 53);
+    R3(b, c, d, e, a, 54); R3(a, b, c, d, e, 55);
+    R3(e, a, b, c, d, 56); R3(d, e, a, b, c, 57);
+    R3(c, d, e, a, b, 58); R3(b, c, d, e, a, 59);
+    R4(a, b, c, d, e, 60); R4(e, a, b, c, d, 61);
+    R4(d, e, a, b, c, 62); R4(c, d, e, a, b, 63);
+    R4(b, c, d, e, a, 64); R4(a, b, c, d, e, 65);
+    R4(e, a, b, c, d, 66); R4(d, e, a, b, c, 67);
+    R4(c, d, e, a, b, 68); R4(b, c, d, e, a, 69);
+    R4(a, b, c, d, e, 70); R4(e, a, b, c, d, 71);
+    R4(d, e, a, b, c, 72); R4(c, d, e, a, b, 73);
+    R4(b, c, d, e, a, 74); R4(a, b, c, d, e, 75);
+    R4(e, a, b, c, d, 76); R4(d, e, a, b, c, 77);
+    R4(c, d, e, a, b, 78); R4(b, c, d, e, a, 79);
+    /* Add the working vars back into context.state[] */
+    state[0] += a;
+    state[1] += b;
+    state[2] += c;
+    state[3] += d;
+    state[4] += e;
+    /* Wipe variables */
+    a = b = c = d = e = 0;
+#ifdef SHA1HANDSOFF
+    memset(block, 0, 64);
+#endif
+}
+
+/* sha1_init - Initialize new context */
+
+void sha1_init(SHA1_CTX *context)
+{
+    /* SHA1 initialization constants */
+    context->state[0] = 0x67452301;
+    context->state[1] = 0xEFCDAB89;
+    context->state[2] = 0x98BADCFE;
+    context->state[3] = 0x10325476;
+    context->state[4] = 0xC3D2E1F0;
+    context->count[0] = context->count[1] = 0;
+}
+
+/* ===== end - public domain SHA1 implementation ===== */

crypto/sha1_i.h

@@ -0,0 +1,21 @@
+/*
+ * SHA1 internal definitions
+ * Copyright (c) 2003-2005, Jouni Malinen <j@w1.fi>
+ *
+ * This software may be distributed under the terms of the BSD license.
+ * See README for more details.
+ */
+
+#ifndef SHA1_I_H
+#define SHA1_I_H
+#include "qemu/osdep.h"
+
+struct sha1_state {
+    uint32_t state[5];
+    uint32_t count[2];
+};
+
+void sha1_init(struct sha1_state *context);
+void sha1_compress(uint32_t state[5], const unsigned char buffer[64]);
+
+#endif /* SHA1_I_H */

crypto/sha256-internal.c

@@ -0,0 +1,107 @@
+/*
+ * SHA-256 hash implementation and interface functions
+ * Copyright (c) 2003-2011, Jouni Malinen <j@w1.fi>
+ *
+ * This software may be distributed under the terms of the BSD license.
+ * See README for more details.
+ */
+
+#include "sha256_i.h"
+
+static inline uint32_t WPA_GET_BE32(const uint8_t *a)
+{
+    return ((uint32_t) a[0] << 24) | (a[1] << 16) | (a[2] << 8) | a[3];
+}
+
+/* ===== start - public domain SHA256 implementation ===== */
+
+/*
+ * This is based on SHA256 implementation in LibTomCrypt that was released into
+ * public domain by Tom St Denis.
+ */
+
+/* the K array */
+static const unsigned long K[64] = {
+        0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL, 0x3956c25bUL,
+        0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL, 0xd807aa98UL, 0x12835b01UL,
+        0x243185beUL, 0x550c7dc3UL, 0x72be5d74UL, 0x80deb1feUL, 0x9bdc06a7UL,
+        0xc19bf174UL, 0xe49b69c1UL, 0xefbe4786UL, 0x0fc19dc6UL, 0x240ca1ccUL,
+        0x2de92c6fUL, 0x4a7484aaUL, 0x5cb0a9dcUL, 0x76f988daUL, 0x983e5152UL,
+        0xa831c66dUL, 0xb00327c8UL, 0xbf597fc7UL, 0xc6e00bf3UL, 0xd5a79147UL,
+        0x06ca6351UL, 0x14292967UL, 0x27b70a85UL, 0x2e1b2138UL, 0x4d2c6dfcUL,
+        0x53380d13UL, 0x650a7354UL, 0x766a0abbUL, 0x81c2c92eUL, 0x92722c85UL,
+        0xa2bfe8a1UL, 0xa81a664bUL, 0xc24b8b70UL, 0xc76c51a3UL, 0xd192e819UL,
+        0xd6990624UL, 0xf40e3585UL, 0x106aa070UL, 0x19a4c116UL, 0x1e376c08UL,
+        0x2748774cUL, 0x34b0bcb5UL, 0x391c0cb3UL, 0x4ed8aa4aUL, 0x5b9cca4fUL,
+        0x682e6ff3UL, 0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL,
+        0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL
+};
+
+/* Compress */
+#define RND(a, b, c, d, e, f, g, h, i) \
+    t0 = h + Sigma1(e) + Ch(e, f, g) + K[i] + W[i]; \
+    t1 = Sigma0(a) + Maj(a, b, c); \
+    d += t0; \
+    h  = t0 + t1;
+/* Various logical functions */
+#define RORc(x, y) \
+(((((unsigned long) (x) & 0xFFFFFFFFUL) >> (unsigned long) ((y) & 31)) | \
+   ((unsigned long) (x) << (unsigned long) (32 - ((y) & 31)))) & 0xFFFFFFFFUL)
+#define Ch(x, y, z)       (z ^ (x & (y ^ z)))
+#define Maj(x, y, z)      (((x | y) & z) | (x & y))
+#define S(x, n)         RORc((x), (n))
+#define R(x, n)         (((x) & 0xFFFFFFFFUL) >> (n))
+#define Sigma0(x)       (S(x, 2) ^ S(x, 13) ^ S(x, 22))
+#define Sigma1(x)       (S(x, 6) ^ S(x, 11) ^ S(x, 25))
+#define Gamma0(x)       (S(x, 7) ^ S(x, 18) ^ R(x, 3))
+#define Gamma1(x)       (S(x, 17) ^ S(x, 19) ^ R(x, 10))
+
+/* compress 512-bits */
+int sha256_compress(struct sha256_state *md, unsigned char *buf)
+{
+    uint32_t S[8], W[64], t0, t1;
+    uint32_t t;
+    int i;
+
+    /* copy state into S */
+    for (i = 0; i < 8; i++) {
+        S[i] = md->state[i];
+    }
+
+    /* copy the state into 512-bits into W[0..15] */
+    for (i = 0; i < 16; i++) {
+        W[i] = WPA_GET_BE32(buf + (4 * i));
+    }
+    /* fill W[16..63] */
+    for (i = 16; i < 64; i++) {
+        W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) +
+               W[i - 16];
+    }
+
+    for (i = 0; i < 64; ++i) {
+        RND(S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7], i);
+        t = S[7]; S[7] = S[6]; S[6] = S[5]; S[5] = S[4];
+        S[4] = S[3]; S[3] = S[2]; S[2] = S[1]; S[1] = S[0]; S[0] = t;
+    }
+
+    /* feedback */
+    for (i = 0; i < 8; i++) {
+        md->state[i] = md->state[i] + S[i];
+    }
+    return 0;
+}
+
+/* Initialize the hash state */
+void sha256_init(struct sha256_state *md)
+{
+    md->state[0] = 0x6A09E667UL;
+    md->state[1] = 0xBB67AE85UL;
+    md->state[2] = 0x3C6EF372UL;
+    md->state[3] = 0xA54FF53AUL;
+    md->state[4] = 0x510E527FUL;
+    md->state[5] = 0x9B05688CUL;
+    md->state[6] = 0x1F83D9ABUL;
+    md->state[7] = 0x5BE0CD19UL;
+}
+
+/* ===== end - public domain SHA256 implementation ===== */

crypto/sha256_i.h

@@ -0,0 +1,20 @@
+/*
+ * SHA-256 internal definitions
+ * Copyright (c) 2003-2011, Jouni Malinen <j@w1.fi>
+ *
+ * This software may be distributed under the terms of the BSD license.
+ * See README for more details.
+ */
+
+#ifndef SHA256_I_H
+#define SHA256_I_H
+#include "qemu/osdep.h"
+
+struct sha256_state {
+    uint32_t state[8];
+};
+
+void sha256_init(struct sha256_state *md);
+int sha256_compress(struct sha256_state *md, unsigned char *buf);
+
+#endif /* SHA256_I_H */