diff options
author | David Gausmann <David.Gausmann@measX.com> | 2021-10-17 19:53:09 +0200 |
---|---|---|
committer | Evgeny Grin (Karlson2k) <k2k@narod.ru> | 2021-10-31 16:02:31 +0300 |
commit | ddad59c1e3a5d20b19003b1d47673501b0665b36 (patch) | |
tree | 8cd367e724477bc092d7dd38c83cd15f4c12c95f /src/microhttpd_ws/sha1.h | |
parent | ffbb000f890f23e14d972a6660168aff4a97b66c (diff) | |
download | libmicrohttpd-ddad59c1e3a5d20b19003b1d47673501b0665b36.tar.gz libmicrohttpd-ddad59c1e3a5d20b19003b1d47673501b0665b36.zip |
websocket update
- added API documentation to libmicrohttpd.texi
- added websocket tutorial chapter to libmicrohttpd-tutorial and an much easier example for the tutorial
- added additional helper functions to ease the HTTP websocket handshake
- the code can now be compiled on Linux without errors
- changed sha1.c and sha1.h to the files provided by Evgeny (I replaced those files in src/microhttpd_ws/ with the files from src/microhttpd/ - maybe there is a smarter way...?)
- removed dependency for "htons" and "htonl" (these functions are now implemented in MHD_websocket.c; no need for OS-dependent files anymore)
- added an additional test script for testing of the library with any webbrowser (for manual practice test)
- several bugfixes
- parameters renamed
- special things clarified (fragmentation, RNG for client mode)
The new version of the API is at some points incompatible with the old version, but since it was in an experimental phase and it didn't compile on Linux, I guess this shouldn't bother anyone.
From my point of view, I am now finished with the library and it could go out of experimental.
Diffstat (limited to 'src/microhttpd_ws/sha1.h')
-rw-r--r-- | src/microhttpd_ws/sha1.h | 245 |
1 files changed, 105 insertions, 140 deletions
diff --git a/src/microhttpd_ws/sha1.h b/src/microhttpd_ws/sha1.h index be0d190b..851a4429 100644 --- a/src/microhttpd_ws/sha1.h +++ b/src/microhttpd_ws/sha1.h | |||
@@ -1,145 +1,110 @@ | |||
1 | /* Declarations of functions and data types used for SHA1 sum | 1 | /* |
2 | library functions. | 2 | This file is part of libmicrohttpd |
3 | Copyright (C) 2000-2021 Free Software Foundation, Inc. | 3 | Copyright (C) 2019-2021 Karlson2k (Evgeny Grin) |
4 | 4 | ||
5 | This program is free software; you can redistribute it and/or modify it | 5 | This library is free software; you can redistribute it and/or |
6 | under the terms of the GNU General Public License as published by the | 6 | modify it under the terms of the GNU Lesser General Public |
7 | Free Software Foundation; either version 3, or (at your option) any | 7 | License as published by the Free Software Foundation; either |
8 | later version. | 8 | version 2.1 of the License, or (at your option) any later version. |
9 | 9 | ||
10 | This program is distributed in the hope that it will be useful, | 10 | This library is distributed in the hope that it will be useful, |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | GNU General Public License for more details. | 13 | Lesser General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU General Public License | 15 | You should have received a copy of the GNU Lesser General Public |
16 | along with this program; if not, write to the Free Software Foundation, | 16 | License along with this library. |
17 | Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ | 17 | If not, see <http://www.gnu.org/licenses/>. |
18 | 18 | */ | |
19 | #ifndef SHA1_H | 19 | |
20 | # define SHA1_H 1 | 20 | /** |
21 | 21 | * @file microhttpd/sha1.h | |
22 | #include <stdio.h> | 22 | * @brief Calculation of SHA-1 digest |
23 | 23 | * @author Karlson2k (Evgeny Grin) | |
24 | #if defined HAVE_LIMITS_H || _LIBC | 24 | */ |
25 | # include <limits.h> | 25 | |
26 | #endif | 26 | #ifndef MHD_SHA1_H |
27 | 27 | #define MHD_SHA1_H 1 | |
28 | /*#include "ansidecl.h"*/ | 28 | |
29 | 29 | #include "mhd_options.h" | |
30 | /* The following contortions are an attempt to use the C preprocessor | ||
31 | to determine an unsigned integral type that is 32 bits wide. An | ||
32 | alternative approach is to use autoconf's AC_CHECK_SIZEOF macro, but | ||
33 | doing that would require that the configure script compile and *run* | ||
34 | the resulting executable. Locally running cross-compiled executables | ||
35 | is usually not possible. */ | ||
36 | |||
37 | #ifdef _LIBC | ||
38 | # include <sys/types.h> | ||
39 | typedef u_int32_t sha1_uint32; | ||
40 | typedef uintptr_t sha1_uintptr; | ||
41 | #elif defined (HAVE_SYS_TYPES_H) && defined (HAVE_STDINT_H) | ||
42 | #include <stdint.h> | 30 | #include <stdint.h> |
43 | #include <sys/types.h> | 31 | #ifdef HAVE_STDDEF_H |
44 | typedef uint32_t sha1_uint32; | 32 | #include <stddef.h> /* for size_t */ |
45 | typedef uintptr_t sha1_uintptr; | 33 | #endif /* HAVE_STDDEF_H */ |
46 | #else | 34 | |
47 | # define INT_MAX_32_BITS 2147483647 | 35 | /** |
48 | 36 | * SHA-1 digest is kept internally as 5 32-bit words. | |
49 | /* If UINT_MAX isn't defined, assume it's a 32-bit type. | 37 | */ |
50 | This should be valid for all systems GNU cares about because | 38 | #define _SHA1_DIGEST_LENGTH 5 |
51 | that doesn't include 16-bit systems, and only modern systems | 39 | |
52 | (that certainly have <limits.h>) have 64+-bit integral types. */ | 40 | /** |
53 | 41 | * Number of bits in single SHA-1 word | |
54 | # ifndef INT_MAX | 42 | */ |
55 | # define INT_MAX INT_MAX_32_BITS | 43 | #define SHA1_WORD_SIZE_BITS 32 |
56 | # endif | 44 | |
57 | 45 | /** | |
58 | # if INT_MAX == INT_MAX_32_BITS | 46 | * Number of bytes in single SHA-1 word |
59 | typedef unsigned int sha1_uint32; | 47 | */ |
60 | # else | 48 | #define SHA1_BYTES_IN_WORD (SHA1_WORD_SIZE_BITS / 8) |
61 | # if SHRT_MAX == INT_MAX_32_BITS | 49 | |
62 | typedef unsigned short sha1_uint32; | 50 | /** |
63 | # else | 51 | * Size of SHA-1 digest in bytes |
64 | # if LONG_MAX == INT_MAX_32_BITS | 52 | */ |
65 | typedef unsigned long sha1_uint32; | 53 | #define SHA1_DIGEST_SIZE (_SHA1_DIGEST_LENGTH * SHA1_BYTES_IN_WORD) |
66 | # else | 54 | |
67 | /* The following line is intended to evoke an error. | 55 | /** |
68 | Using #error is not portable enough. */ | 56 | * Size of SHA-1 digest string in chars including termination NUL |
69 | "Cannot determine unsigned 32-bit data type." | 57 | */ |
70 | # endif | 58 | #define SHA1_DIGEST_STRING_SIZE ((SHA1_DIGEST_SIZE) * 2 + 1) |
71 | # endif | 59 | |
72 | # endif | 60 | /** |
73 | #endif | 61 | * Size of single processing block in bits |
74 | 62 | */ | |
75 | #ifdef __cplusplus | 63 | #define SHA1_BLOCK_SIZE_BITS 512 |
76 | extern "C" { | 64 | |
77 | #endif | 65 | /** |
78 | 66 | * Size of single processing block in bytes | |
79 | /* Structure to save state of computation between the single steps. */ | 67 | */ |
68 | #define SHA1_BLOCK_SIZE (SHA1_BLOCK_SIZE_BITS / 8) | ||
69 | |||
70 | |||
80 | struct sha1_ctx | 71 | struct sha1_ctx |
81 | { | 72 | { |
82 | sha1_uint32 A; | 73 | uint32_t H[_SHA1_DIGEST_LENGTH]; /**< Intermediate hash value / digest at end of calculation */ |
83 | sha1_uint32 B; | 74 | uint8_t buffer[SHA1_BLOCK_SIZE]; /**< SHA256 input data buffer */ |
84 | sha1_uint32 C; | 75 | uint64_t count; /**< number of bytes, mod 2^64 */ |
85 | sha1_uint32 D; | ||
86 | sha1_uint32 E; | ||
87 | |||
88 | sha1_uint32 total[2]; | ||
89 | sha1_uint32 buflen; | ||
90 | sha1_uint32 buffer[32]; | ||
91 | }; | 76 | }; |
92 | 77 | ||
93 | 78 | /** | |
94 | /* Initialize structure containing state of computation. */ | 79 | * Initialise structure for SHA-1 calculation. |
95 | extern void sha1_init_ctx (struct sha1_ctx *ctx); | 80 | * |
96 | 81 | * @param ctx must be a `struct sha1_ctx *` | |
97 | /* Starting with the result of former calls of this function (or the | 82 | */ |
98 | initialization function update the context for the next LEN bytes | 83 | void |
99 | starting at BUFFER. | 84 | MHD_SHA1_init (void *ctx_); |
100 | It is necessary that LEN is a multiple of 64!!! */ | 85 | |
101 | extern void sha1_process_block (const void *buffer, size_t len, | 86 | |
102 | struct sha1_ctx *ctx); | 87 | /** |
103 | 88 | * Process portion of bytes. | |
104 | /* Starting with the result of former calls of this function (or the | 89 | * |
105 | initialization function update the context for the next LEN bytes | 90 | * @param ctx_ must be a `struct sha1_ctx *` |
106 | starting at BUFFER. | 91 | * @param data bytes to add to hash |
107 | It is NOT required that LEN is a multiple of 64. */ | 92 | * @param length number of bytes in @a data |
108 | extern void sha1_process_bytes (const void *buffer, size_t len, | 93 | */ |
109 | struct sha1_ctx *ctx); | 94 | void |
110 | 95 | MHD_SHA1_update (void *ctx_, | |
111 | /* Process the remaining bytes in the buffer and put result from CTX | 96 | const uint8_t *data, |
112 | in first 20 bytes following RESBUF. The result is always in little | 97 | size_t length); |
113 | endian byte order, so that a byte-wise output yields to the wanted | 98 | |
114 | ASCII representation of the message digest. | 99 | |
115 | 100 | /** | |
116 | IMPORTANT: On some systems it is required that RESBUF be correctly | 101 | * Finalise SHA-1 calculation, return digest. |
117 | aligned for a 32 bits value. */ | 102 | * |
118 | extern void *sha1_finish_ctx (struct sha1_ctx *ctx, void *resbuf); | 103 | * @param ctx_ must be a `struct sha1_ctx *` |
119 | 104 | * @param[out] digest set to the hash, must be #SHA1_DIGEST_SIZE bytes | |
120 | 105 | */ | |
121 | /* Put result from CTX in first 20 bytes following RESBUF. The result is | 106 | void |
122 | always in little endian byte order, so that a byte-wise output yields | 107 | MHD_SHA1_finish (void *ctx_, |
123 | to the wanted ASCII representation of the message digest. | 108 | uint8_t digest[SHA1_DIGEST_SIZE]); |
124 | 109 | ||
125 | IMPORTANT: On some systems it is required that RESBUF is correctly | 110 | #endif /* MHD_SHA1_H */ |
126 | aligned for a 32 bits value. */ | ||
127 | extern void *sha1_read_ctx (const struct sha1_ctx *ctx, void *resbuf); | ||
128 | |||
129 | |||
130 | /* Compute SHA1 message digest for bytes read from STREAM. The | ||
131 | resulting message digest number will be written into the 20 bytes | ||
132 | beginning at RESBLOCK. */ | ||
133 | extern int sha1_stream (FILE *stream, void *resblock); | ||
134 | |||
135 | /* Compute SHA1 message digest for LEN bytes beginning at BUFFER. The | ||
136 | result is always in little endian byte order, so that a byte-wise | ||
137 | output yields to the wanted ASCII representation of the message | ||
138 | digest. */ | ||
139 | extern void *sha1_buffer (const char *buffer, size_t len, void *resblock); | ||
140 | |||
141 | #ifdef __cplusplus | ||
142 | } | ||
143 | #endif | ||
144 | |||
145 | #endif | ||