Restoring authorship annotation for <thegeorg@yandex-team.ru>. Commit 2 of 2.

1 files changed, 254 insertions, 254 deletions

diff --git a/contrib/libs/curl/lib/sha256.c b/contrib/libs/curl/lib/sha256.c
index e1b3459bbb..7d2a4f705a 100644
--- a/contrib/libs/curl/lib/sha256.c
+++ b/contrib/libs/curl/lib/sha256.c
@@ -5,12 +5,12 @@
  *                            | (__| |_| |  _ <| |___
  *                             \___|\___/|_| \_\_____|
  *
- * Copyright (C) 2017, Florin Petriuc, <petriuc.florin@gmail.com> 
- * Copyright (C) 2018 - 2020, Daniel Stenberg, <daniel@haxx.se>, et al. 
+ * Copyright (C) 2017, Florin Petriuc, <petriuc.florin@gmail.com>
+ * Copyright (C) 2018 - 2020, Daniel Stenberg, <daniel@haxx.se>, et al.
  *
  * This software is licensed as described in the file COPYING, which
  * you should have received as part of this distribution. The terms
- * are also available at https://curl.se/docs/copyright.html. 
+ * are also available at https://curl.se/docs/copyright.html.
  *
  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  * copies of the Software, and permit persons to whom the Software is
@@ -36,208 +36,208 @@
 #define USE_OPENSSL_SHA256
 #endif
 
-#endif /* USE_OPENSSL */ 
- 
-#ifdef USE_MBEDTLS 
-#error #include <mbedtls/version.h> 
- 
-#if(MBEDTLS_VERSION_NUMBER >= 0x02070000) 
-  #define HAS_RESULT_CODE_BASED_FUNCTIONS 
+#endif /* USE_OPENSSL */
+
+#ifdef USE_MBEDTLS
+#error #include <mbedtls/version.h>
+
+#if(MBEDTLS_VERSION_NUMBER >= 0x02070000)
+  #define HAS_RESULT_CODE_BASED_FUNCTIONS
 #endif
-#endif /* USE_MBEDTLS */ 
-
-/* Please keep the SSL backend-specific #if branches in this order: 
- * 
- * 1. USE_OPENSSL 
- * 2. USE_GNUTLS_NETTLE 
- * 3. USE_GNUTLS 
- * 4. USE_MBEDTLS 
- * 5. USE_COMMON_CRYPTO 
- * 6. USE_WIN32_CRYPTO 
- * 
- * This ensures that the same SSL branch gets activated throughout this source 
- * file even if multiple backends are enabled at the same time. 
- */ 
- 
-#if defined(USE_OPENSSL_SHA256) 
- 
+#endif /* USE_MBEDTLS */
+
+/* Please keep the SSL backend-specific #if branches in this order:
+ *
+ * 1. USE_OPENSSL
+ * 2. USE_GNUTLS_NETTLE
+ * 3. USE_GNUTLS
+ * 4. USE_MBEDTLS
+ * 5. USE_COMMON_CRYPTO
+ * 6. USE_WIN32_CRYPTO
+ *
+ * This ensures that the same SSL branch gets activated throughout this source
+ * file even if multiple backends are enabled at the same time.
+ */
+
+#if defined(USE_OPENSSL_SHA256)
+
 /* When OpenSSL is available we use the SHA256-function from OpenSSL */
 #include <openssl/sha.h>
- 
-#elif defined(USE_GNUTLS_NETTLE) 
- 
-#error #include <nettle/sha.h> 
- 
-#include "curl_memory.h" 
- 
-/* The last #include file should be: */ 
-#include "memdebug.h" 
- 
-typedef struct sha256_ctx SHA256_CTX; 
- 
-static void SHA256_Init(SHA256_CTX *ctx) 
-{ 
-  sha256_init(ctx); 
-} 
- 
-static void SHA256_Update(SHA256_CTX *ctx, 
-                          const unsigned char *data, 
-                          unsigned int length) 
-{ 
-  sha256_update(ctx, length, data); 
-} 
- 
-static void SHA256_Final(unsigned char *digest, SHA256_CTX *ctx) 
-{ 
-  sha256_digest(ctx, SHA256_DIGEST_SIZE, digest); 
-} 
- 
-#elif defined(USE_GNUTLS) 
- 
-#include <gcrypt.h> 
- 
-#include "curl_memory.h" 
- 
-/* The last #include file should be: */ 
-#include "memdebug.h" 
- 
-typedef gcry_md_hd_t SHA256_CTX; 
- 
-static void SHA256_Init(SHA256_CTX *ctx) 
-{ 
-  gcry_md_open(ctx, GCRY_MD_SHA256, 0); 
-} 
- 
-static void SHA256_Update(SHA256_CTX *ctx, 
-                          const unsigned char *data, 
-                          unsigned int length) 
-{ 
-  gcry_md_write(*ctx, data, length); 
-} 
- 
-static void SHA256_Final(unsigned char *digest, SHA256_CTX *ctx) 
-{ 
-  memcpy(digest, gcry_md_read(*ctx, 0), SHA256_DIGEST_LENGTH); 
-  gcry_md_close(*ctx); 
-} 
- 
-#elif defined(USE_MBEDTLS) 
- 
-#error #include <mbedtls/sha256.h> 
- 
-#include "curl_memory.h" 
- 
-/* The last #include file should be: */ 
-#include "memdebug.h" 
- 
-typedef mbedtls_sha256_context SHA256_CTX; 
- 
-static void SHA256_Init(SHA256_CTX *ctx) 
-{ 
-#if !defined(HAS_RESULT_CODE_BASED_FUNCTIONS) 
-  mbedtls_sha256_starts(ctx, 0); 
+
+#elif defined(USE_GNUTLS_NETTLE)
+
+#error #include <nettle/sha.h>
+
+#include "curl_memory.h"
+
+/* The last #include file should be: */
+#include "memdebug.h"
+
+typedef struct sha256_ctx SHA256_CTX;
+
+static void SHA256_Init(SHA256_CTX *ctx)
+{
+  sha256_init(ctx);
+}
+
+static void SHA256_Update(SHA256_CTX *ctx,
+                          const unsigned char *data,
+                          unsigned int length)
+{
+  sha256_update(ctx, length, data);
+}
+
+static void SHA256_Final(unsigned char *digest, SHA256_CTX *ctx)
+{
+  sha256_digest(ctx, SHA256_DIGEST_SIZE, digest);
+}
+
+#elif defined(USE_GNUTLS)
+
+#include <gcrypt.h>
+
+#include "curl_memory.h"
+
+/* The last #include file should be: */
+#include "memdebug.h"
+
+typedef gcry_md_hd_t SHA256_CTX;
+
+static void SHA256_Init(SHA256_CTX *ctx)
+{
+  gcry_md_open(ctx, GCRY_MD_SHA256, 0);
+}
+
+static void SHA256_Update(SHA256_CTX *ctx,
+                          const unsigned char *data,
+                          unsigned int length)
+{
+  gcry_md_write(*ctx, data, length);
+}
+
+static void SHA256_Final(unsigned char *digest, SHA256_CTX *ctx)
+{
+  memcpy(digest, gcry_md_read(*ctx, 0), SHA256_DIGEST_LENGTH);
+  gcry_md_close(*ctx);
+}
+
+#elif defined(USE_MBEDTLS)
+
+#error #include <mbedtls/sha256.h>
+
+#include "curl_memory.h"
+
+/* The last #include file should be: */
+#include "memdebug.h"
+
+typedef mbedtls_sha256_context SHA256_CTX;
+
+static void SHA256_Init(SHA256_CTX *ctx)
+{
+#if !defined(HAS_RESULT_CODE_BASED_FUNCTIONS)
+  mbedtls_sha256_starts(ctx, 0);
+#else
+  (void) mbedtls_sha256_starts_ret(ctx, 0);
+#endif
+}
+
+static void SHA256_Update(SHA256_CTX *ctx,
+                          const unsigned char *data,
+                          unsigned int length)
+{
+#if !defined(HAS_RESULT_CODE_BASED_FUNCTIONS)
+  mbedtls_sha256_update(ctx, data, length);
+#else
+  (void) mbedtls_sha256_update_ret(ctx, data, length);
+#endif
+}
+
+static void SHA256_Final(unsigned char *digest, SHA256_CTX *ctx)
+{
+#if !defined(HAS_RESULT_CODE_BASED_FUNCTIONS)
+  mbedtls_sha256_finish(ctx, digest);
+#else
+  (void) mbedtls_sha256_finish_ret(ctx, digest);
+#endif
+}
+
+#elif (defined(__MAC_OS_X_VERSION_MAX_ALLOWED) && \
+              (__MAC_OS_X_VERSION_MAX_ALLOWED >= 1040)) || \
+      (defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && \
+              (__IPHONE_OS_VERSION_MAX_ALLOWED >= 20000))
+
+#include <CommonCrypto/CommonDigest.h>
+
+#include "curl_memory.h"
+
+/* The last #include file should be: */
+#include "memdebug.h"
+
+typedef CC_SHA256_CTX SHA256_CTX;
+
+static void SHA256_Init(SHA256_CTX *ctx)
+{
+  (void) CC_SHA256_Init(ctx);
+}
+
+static void SHA256_Update(SHA256_CTX *ctx,
+                          const unsigned char *data,
+                          unsigned int length)
+{
+  (void) CC_SHA256_Update(ctx, data, length);
+}
+
+static void SHA256_Final(unsigned char *digest, SHA256_CTX *ctx)
+{
+  (void) CC_SHA256_Final(digest, ctx);
+}
+
+#elif defined(USE_WIN32_CRYPTO)
+
+#include <wincrypt.h>
+
+struct sha256_ctx {
+  HCRYPTPROV hCryptProv;
+  HCRYPTHASH hHash;
+};
+typedef struct sha256_ctx SHA256_CTX;
+
+#if !defined(CALG_SHA_256)
+#define CALG_SHA_256 0x0000800c
+#endif
+
+static void SHA256_Init(SHA256_CTX *ctx)
+{
+  if(CryptAcquireContext(&ctx->hCryptProv, NULL, NULL, PROV_RSA_AES,
+                         CRYPT_VERIFYCONTEXT | CRYPT_SILENT)) {
+    CryptCreateHash(ctx->hCryptProv, CALG_SHA_256, 0, 0, &ctx->hHash);
+  }
+}
+
+static void SHA256_Update(SHA256_CTX *ctx,
+                          const unsigned char *data,
+                          unsigned int length)
+{
+  CryptHashData(ctx->hHash, (unsigned char *) data, length, 0);
+}
+
+static void SHA256_Final(unsigned char *digest, SHA256_CTX *ctx)
+{
+  unsigned long length = 0;
+
+  CryptGetHashParam(ctx->hHash, HP_HASHVAL, NULL, &length, 0);
+  if(length == SHA256_DIGEST_LENGTH)
+    CryptGetHashParam(ctx->hHash, HP_HASHVAL, digest, &length, 0);
+
+  if(ctx->hHash)
+    CryptDestroyHash(ctx->hHash);
+
+  if(ctx->hCryptProv)
+    CryptReleaseContext(ctx->hCryptProv, 0);
+}
+
 #else
-  (void) mbedtls_sha256_starts_ret(ctx, 0); 
-#endif 
-} 
-
-static void SHA256_Update(SHA256_CTX *ctx, 
-                          const unsigned char *data, 
-                          unsigned int length) 
-{ 
-#if !defined(HAS_RESULT_CODE_BASED_FUNCTIONS) 
-  mbedtls_sha256_update(ctx, data, length); 
-#else 
-  (void) mbedtls_sha256_update_ret(ctx, data, length); 
-#endif 
-} 
- 
-static void SHA256_Final(unsigned char *digest, SHA256_CTX *ctx) 
-{ 
-#if !defined(HAS_RESULT_CODE_BASED_FUNCTIONS) 
-  mbedtls_sha256_finish(ctx, digest); 
-#else 
-  (void) mbedtls_sha256_finish_ret(ctx, digest); 
-#endif 
-} 
- 
-#elif (defined(__MAC_OS_X_VERSION_MAX_ALLOWED) && \ 
-              (__MAC_OS_X_VERSION_MAX_ALLOWED >= 1040)) || \ 
-      (defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && \ 
-              (__IPHONE_OS_VERSION_MAX_ALLOWED >= 20000)) 
- 
-#include <CommonCrypto/CommonDigest.h> 
- 
-#include "curl_memory.h" 
- 
-/* The last #include file should be: */ 
-#include "memdebug.h" 
- 
-typedef CC_SHA256_CTX SHA256_CTX; 
- 
-static void SHA256_Init(SHA256_CTX *ctx) 
-{ 
-  (void) CC_SHA256_Init(ctx); 
-} 
- 
-static void SHA256_Update(SHA256_CTX *ctx, 
-                          const unsigned char *data, 
-                          unsigned int length) 
-{ 
-  (void) CC_SHA256_Update(ctx, data, length); 
-} 
- 
-static void SHA256_Final(unsigned char *digest, SHA256_CTX *ctx) 
-{ 
-  (void) CC_SHA256_Final(digest, ctx); 
-} 
- 
-#elif defined(USE_WIN32_CRYPTO) 
- 
-#include <wincrypt.h> 
- 
-struct sha256_ctx { 
-  HCRYPTPROV hCryptProv; 
-  HCRYPTHASH hHash; 
-}; 
-typedef struct sha256_ctx SHA256_CTX; 
- 
-#if !defined(CALG_SHA_256) 
-#define CALG_SHA_256 0x0000800c 
-#endif 
- 
-static void SHA256_Init(SHA256_CTX *ctx) 
-{ 
-  if(CryptAcquireContext(&ctx->hCryptProv, NULL, NULL, PROV_RSA_AES, 
-                         CRYPT_VERIFYCONTEXT | CRYPT_SILENT)) { 
-    CryptCreateHash(ctx->hCryptProv, CALG_SHA_256, 0, 0, &ctx->hHash); 
-  } 
-} 
- 
-static void SHA256_Update(SHA256_CTX *ctx, 
-                          const unsigned char *data, 
-                          unsigned int length) 
-{ 
-  CryptHashData(ctx->hHash, (unsigned char *) data, length, 0); 
-} 
- 
-static void SHA256_Final(unsigned char *digest, SHA256_CTX *ctx) 
-{ 
-  unsigned long length = 0; 
- 
-  CryptGetHashParam(ctx->hHash, HP_HASHVAL, NULL, &length, 0); 
-  if(length == SHA256_DIGEST_LENGTH) 
-    CryptGetHashParam(ctx->hHash, HP_HASHVAL, digest, &length, 0); 
- 
-  if(ctx->hHash) 
-    CryptDestroyHash(ctx->hHash); 
- 
-  if(ctx->hCryptProv) 
-    CryptReleaseContext(ctx->hCryptProv, 0); 
-} 
- 
-#else 
- 
+
 /* When no other crypto library is available we use this code segment */
 
 /* This is based on SHA256 implementation in LibTomCrypt that was released into
@@ -281,7 +281,7 @@ do {                                                          \
 } while(0)
 #endif
 
-struct sha256_state { 
+struct sha256_state {
 #ifdef HAVE_LONGLONG
   unsigned long long length;
 #else
@@ -289,10 +289,10 @@ struct sha256_state {
 #endif
   unsigned long state[8], curlen;
   unsigned char buf[64];
-}; 
-typedef struct sha256_state SHA256_CTX; 
- 
-/* The K array */ 
+};
+typedef struct sha256_state SHA256_CTX;
+
+/* The K array */
 static const unsigned long K[64] = {
   0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL, 0x3956c25bUL,
   0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL, 0xd807aa98UL, 0x12835b01UL,
@@ -308,7 +308,7 @@ static const unsigned long K[64] = {
   0x682e6ff3UL, 0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL,
   0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL
 };
- 
+
 /* Various logical functions */
 #define RORc(x, y) \
 (((((unsigned long)(x) & 0xFFFFFFFFUL) >> (unsigned long)((y) & 31)) | \
@@ -321,15 +321,15 @@ static const unsigned long K[64] = {
 #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 */ 
+
+/* Compress 512-bits */
 static int sha256_compress(struct sha256_state *md,
                            unsigned char *buf)
 {
   unsigned long S[8], W[64];
   int i;
- 
-  /* Copy state into S */ 
+
+  /* Copy state into S */
   for(i = 0; i < 8; i++) {
     S[i] = md->state[i];
   }
@@ -341,7 +341,7 @@ static int sha256_compress(struct sha256_state *md,
     W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) +
       W[i - 16];
   }
- 
+
   /* Compress */
 #define RND(a,b,c,d,e,f,g,h,i)                                  \
   unsigned long t0 = h + Sigma1(e) + Ch(e, f, g) + K[i] + W[i]; \
@@ -354,15 +354,15 @@ static int sha256_compress(struct sha256_state *md,
     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 */ 
+
+  /* Feedback */
   for(i = 0; i < 8; i++) {
     md->state[i] = md->state[i] + S[i];
   }
- 
+
   return 0;
 }
- 
+
 /* Initialize the hash state */
 static void SHA256_Init(struct sha256_state *md)
 {
@@ -377,8 +377,8 @@ static void SHA256_Init(struct sha256_state *md)
   md->state[6] = 0x1F83D9ABUL;
   md->state[7] = 0x5BE0CD19UL;
 }
- 
-/* 
+
+/*
    Process a block of memory though the hash
    @param md     The hash state
    @param in     The data to hash
@@ -390,7 +390,7 @@ static int SHA256_Update(struct sha256_state *md,
                          unsigned long inlen)
 {
   unsigned long n;
- 
+
 #define block_size 64
   if(md->curlen > sizeof(md->buf))
     return -1;
@@ -416,11 +416,11 @@ static int SHA256_Update(struct sha256_state *md,
       }
     }
   }
- 
+
   return 0;
 }
- 
-/* 
+
+/*
    Terminate the hash to get the digest
    @param md  The hash state
    @param out [out] The destination of the hash (32 bytes)
@@ -430,17 +430,17 @@ static int SHA256_Final(unsigned char *out,
                         struct sha256_state *md)
 {
   int i;
- 
+
   if(md->curlen >= sizeof(md->buf))
     return -1;
- 
-  /* Increase the length of the message */ 
+
+  /* Increase the length of the message */
   md->length += md->curlen * 8;
- 
-  /* Append the '1' bit */ 
+
+  /* Append the '1' bit */
   md->buf[md->curlen++] = (unsigned char)0x80;
- 
-  /* If the length is currently above 56 bytes we append zeros 
+
+  /* If the length is currently above 56 bytes we append zeros
    * then compress.  Then we can fall back to padding zeros and length
    * encoding like normal.
    */
@@ -451,44 +451,44 @@ static int SHA256_Final(unsigned char *out,
     sha256_compress(md, md->buf);
     md->curlen = 0;
   }
- 
-  /* Pad up to 56 bytes of zeroes */ 
+
+  /* Pad up to 56 bytes of zeroes */
   while(md->curlen < 56) {
     md->buf[md->curlen++] = (unsigned char)0;
   }
- 
-  /* Store length */ 
+
+  /* Store length */
   WPA_PUT_BE64(md->buf + 56, md->length);
   sha256_compress(md, md->buf);
- 
-  /* Copy output */ 
+
+  /* Copy output */
   for(i = 0; i < 8; i++)
     WPA_PUT_BE32(out + (4 * i), md->state[i]);
- 
+
   return 0;
 }
 
-#endif /* CRYPTO LIBS */ 
-
-/* 
- * Curl_sha256it() 
- * 
- * Generates a SHA256 hash for the given input data. 
- * 
- * Parameters: 
- * 
- * output [in/out] - The output buffer. 
- * input  [in]     - The input data. 
- * length [in]     - The input length. 
- */ 
-void Curl_sha256it(unsigned char *output, const unsigned char *input, 
-                   const size_t length) 
+#endif /* CRYPTO LIBS */
+
+/*
+ * Curl_sha256it()
+ *
+ * Generates a SHA256 hash for the given input data.
+ *
+ * Parameters:
+ *
+ * output [in/out] - The output buffer.
+ * input  [in]     - The input data.
+ * length [in]     - The input length.
+ */
+void Curl_sha256it(unsigned char *output, const unsigned char *input,
+                   const size_t length)
 {
   SHA256_CTX ctx;
- 
+
   SHA256_Init(&ctx);
-  SHA256_Update(&ctx, input, curlx_uztoui(length)); 
-  SHA256_Final(output, &ctx); 
+  SHA256_Update(&ctx, input, curlx_uztoui(length));
+  SHA256_Final(output, &ctx);
 }
 
 #endif /* CURL_DISABLE_CRYPTO_AUTH */