13813968540

Committed 12 Mar 2025 02:33PM UTC coverage: 70.43% (-0.02%) from 70.446%

Build # 13813968540

Build Type

Pull #11951

github

Committed by

web-flow

Commit Message

Merge 0560ed8f8 into 5ab779ac6

Pull Request Pull Request #11951: Doc: Build docs using CMake

Run Details

553276 of 785573 relevant lines covered (70.43%)

222076.27 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.35

/port/cpl_sha1.cpp

/******************************************************************************
 *
 * Project:  CPL - Common Portability Library
 * Purpose:  Implement SHA1
 * Author:   Even Rouault, even.rouault at spatialys.com
 *
 * SHA1 computation coming from Public Domain code at:
 * https://github.com/B-Con/crypto-algorithms/blob/master/sha1.c
 * by Brad Conte (brad AT bradconte.com)
 *
 ******************************************************************************
 * Copyright (c) 2017, Even Rouault <even.rouault at spatialys.com>
 *
 * SPDX-License-Identifier: MIT
 ****************************************************************************/

#include <string.h>
#include "cpl_sha1.h"

typedef struct
{
    GByte data[64];
    GUInt32 datalen;
    GUIntBig bitlen;
    GUInt32 state[5];
} CPL_SHA1Context;

#define ROTLEFT(a, b) ((a << b) | (a >> (32 - b)))

/************************************************************************/
/*                         sha1_transform()                             */
/************************************************************************/

CPL_NOSANITIZE_UNSIGNED_INT_OVERFLOW
static void sha1_transform(CPL_SHA1Context *ctx, const GByte data[])
{
    GUInt32 a, b, c, d, e, i, j, t, m[80];

    for (i = 0, j = 0; i < 16; ++i, j += 4)
        m[i] = (data[j] << 24) + (data[j + 1] << 16) + (data[j + 2] << 8) +
               (data[j + 3]);
    for (; i < 80; ++i)
    {
        m[i] = (m[i - 3] ^ m[i - 8] ^ m[i - 14] ^ m[i - 16]);
        m[i] = (m[i] << 1) | (m[i] >> 31);
    }

    a = ctx->state[0];
    b = ctx->state[1];
    c = ctx->state[2];
    d = ctx->state[3];
    e = ctx->state[4];

    for (i = 0; i < 20; ++i)
    {
        t = ROTLEFT(a, 5) + ((b & c) ^ (~b & d)) + e + 0x5a827999U + m[i];
        e = d;
        d = c;
        c = ROTLEFT(b, 30);
        b = a;
        a = t;
    }
    for (; i < 40; ++i)
    {
        t = ROTLEFT(a, 5) + (b ^ c ^ d) + e + 0x6ed9eba1U + m[i];
        e = d;
        d = c;
        c = ROTLEFT(b, 30);
        b = a;
        a = t;
    }
    for (; i < 60; ++i)
    {
        t = ROTLEFT(a, 5) + ((b & c) ^ (b & d) ^ (c & d)) + e + 0x8f1bbcdcU +
            m[i];
        e = d;
        d = c;
        c = ROTLEFT(b, 30);
        b = a;
        a = t;
    }
    for (; i < 80; ++i)
    {
        t = ROTLEFT(a, 5) + (b ^ c ^ d) + e + 0xca62c1d6U + m[i];
        e = d;
        d = c;
        c = ROTLEFT(b, 30);
        b = a;
        a = t;
    }

    ctx->state[0] += a;
    ctx->state[1] += b;
    ctx->state[2] += c;
    ctx->state[3] += d;
    ctx->state[4] += e;
}

/************************************************************************/
/*                           CPL_SHA1Init()                             */
/************************************************************************/

static void CPL_SHA1Init(CPL_SHA1Context *ctx)
{
    ctx->datalen = 0;
    ctx->bitlen = 0;
    ctx->state[0] = 0x67452301U;
    ctx->state[1] = 0xEFCDAB89U;
    ctx->state[2] = 0x98BADCFEU;
    ctx->state[3] = 0x10325476U;
    ctx->state[4] = 0xc3d2e1f0U;
}

/************************************************************************/
/*                          CPL_SHA1Update()                            */
/************************************************************************/

static void CPL_SHA1Update(CPL_SHA1Context *ctx, const GByte data[], size_t len)
{
    size_t i;

    for (i = 0; i < len; ++i)
    {
        ctx->data[ctx->datalen] = data[i];
        ctx->datalen++;
        if (ctx->datalen == 64)
        {
            sha1_transform(ctx, ctx->data);
            ctx->bitlen += 512;
            ctx->datalen = 0;
        }
    }
}

/************************************************************************/
/*                           CPL_SHA1Final()                            */
/************************************************************************/

static void CPL_SHA1Final(CPL_SHA1Context *ctx, GByte hash[CPL_SHA1_HASH_SIZE])
{
    GUInt32 i;

    i = ctx->datalen;

    // Pad whatever data is left in the buffer.
    if (ctx->datalen < 56)
    {
        ctx->data[i++] = 0x80;
        while (i < 56)
            ctx->data[i++] = 0x00;
    }
    else
    {
        ctx->data[i++] = 0x80;
        while (i < 64)
            ctx->data[i++] = 0x00;
        sha1_transform(ctx, ctx->data);
        memset(ctx->data, 0, 56);
    }

    // Append to the padding the total message's length in bits and transform.
    ctx->bitlen += ctx->datalen * 8;
    ctx->data[63] = static_cast<GByte>((ctx->bitlen) & 0xFFU);
    ctx->data[62] = static_cast<GByte>((ctx->bitlen >> 8) & 0xFFU);
    ctx->data[61] = static_cast<GByte>((ctx->bitlen >> 16) & 0xFFU);
    ctx->data[60] = static_cast<GByte>((ctx->bitlen >> 24) & 0xFFU);
    ctx->data[59] = static_cast<GByte>((ctx->bitlen >> 32) & 0xFFU);
    ctx->data[58] = static_cast<GByte>((ctx->bitlen >> 40) & 0xFFU);
    ctx->data[57] = static_cast<GByte>((ctx->bitlen >> 48) & 0xFFU);
    ctx->data[56] = static_cast<GByte>((ctx->bitlen >> 56) & 0xFFU);
    sha1_transform(ctx, ctx->data);

    // Since this implementation uses little endian byte ordering and MD uses
    // big endian, reverse all the bytes when copying the final state to the
    // output hash.
    for (i = 0; i < 4; ++i)
    {
        hash[i] =
            static_cast<GByte>((ctx->state[0] >> (24 - i * 8)) & 0x000000ffU);
        hash[i + 4] =
            static_cast<GByte>((ctx->state[1] >> (24 - i * 8)) & 0x000000ffU);
        hash[i + 8] =
            static_cast<GByte>((ctx->state[2] >> (24 - i * 8)) & 0x000000ffU);
        hash[i + 12] =
            static_cast<GByte>((ctx->state[3] >> (24 - i * 8)) & 0x000000ffU);
        hash[i + 16] =
            static_cast<GByte>((ctx->state[4] >> (24 - i * 8)) & 0x000000ffU);
    }
}

/************************************************************************/
/*                              CPL_SHA1()                              */
/************************************************************************/

void CPL_SHA1(const void *data, size_t len, GByte hash[CPL_SHA1_HASH_SIZE])
{
    CPL_SHA1Context sSHA1Ctxt;
    CPL_SHA1Init(&sSHA1Ctxt);
    CPL_SHA1Update(&sSHA1Ctxt, static_cast<const GByte *>(data), len);
    CPL_SHA1Final(&sSHA1Ctxt, hash);
    memset(&sSHA1Ctxt, 0, sizeof(sSHA1Ctxt));
}

/************************************************************************/
/*                           CPL_HMAC_SHA1()                            */
/************************************************************************/

#define CPL_HMAC_SHA1_BLOCKSIZE 64U

// See
// https://en.wikipedia.org/wiki/Hash-based_message_authentication_code#Implementation
void CPL_HMAC_SHA1(const void *pKey, size_t nKeyLen, const void *pabyMessage,
                   size_t nMessageLen, GByte abyDigest[CPL_SHA1_HASH_SIZE])
{
    GByte abyPad[CPL_HMAC_SHA1_BLOCKSIZE] = {};
    if (nKeyLen > CPL_HMAC_SHA1_BLOCKSIZE)
    {
        CPL_SHA1(pKey, nKeyLen, abyPad);
    }
    else
    {
        memcpy(abyPad, pKey, nKeyLen);
    }

    // Compute ipad.
    for (size_t i = 0; i < CPL_HMAC_SHA1_BLOCKSIZE; i++)
        abyPad[i] = 0x36 ^ abyPad[i];

    CPL_SHA1Context sSHA1Ctxt;
    CPL_SHA1Init(&sSHA1Ctxt);
    CPL_SHA1Update(&sSHA1Ctxt, abyPad, CPL_HMAC_SHA1_BLOCKSIZE);
    CPL_SHA1Update(&sSHA1Ctxt, static_cast<const GByte *>(pabyMessage),
                   nMessageLen);
    CPL_SHA1Final(&sSHA1Ctxt, abyDigest);

    // Compute opad.
    for (size_t i = 0; i < CPL_HMAC_SHA1_BLOCKSIZE; i++)
        abyPad[i] = (0x36 ^ 0x5C) ^ abyPad[i];

    CPL_SHA1Init(&sSHA1Ctxt);
    CPL_SHA1Update(&sSHA1Ctxt, abyPad, CPL_HMAC_SHA1_BLOCKSIZE);
    CPL_SHA1Update(&sSHA1Ctxt, abyDigest, CPL_SHA1_HASH_SIZE);
    CPL_SHA1Final(&sSHA1Ctxt, abyDigest);

    memset(&sSHA1Ctxt, 0, sizeof(sSHA1Ctxt));
    memset(abyPad, 0, CPL_HMAC_SHA1_BLOCKSIZE);
}

1	/******************************************************************************
2	*
3	* Project: CPL - Common Portability Library
4	* Purpose: Implement SHA1
5	* Author: Even Rouault, even.rouault at spatialys.com
6	*
7	* SHA1 computation coming from Public Domain code at:
8	* https://github.com/B-Con/crypto-algorithms/blob/master/sha1.c
9	* by Brad Conte (brad AT bradconte.com)
10	*
11	******************************************************************************
12	* Copyright (c) 2017, Even Rouault <even.rouault at spatialys.com>
13	*
14	* SPDX-License-Identifier: MIT
15	****************************************************************************/
16
17	#include <string.h>
18	#include "cpl_sha1.h"
19
20	typedef struct
21	{
22	GByte data[64];
23	GUInt32 datalen;
24	GUIntBig bitlen;
25	GUInt32 state[5];
26	} CPL_SHA1Context;
27
28	#define ROTLEFT(a, b) ((a << b) \| (a >> (32 - b)))
29
30	/************************************************************************/
31	/* sha1_transform() */
32	/************************************************************************/
33
34	CPL_NOSANITIZE_UNSIGNED_INT_OVERFLOW
35	static void sha1_transform(CPL_SHA1Context *ctx, const GByte data[])	435✔
36	{
37	GUInt32 a, b, c, d, e, i, j, t, m[80];
38
39	for (i = 0, j = 0; i < 16; ++i, j += 4)	7,395✔
40	m[i] = (data[j] << 24) + (data[j + 1] << 16) + (data[j + 2] << 8) +	6,960✔
41	(data[j + 3]);	6,960✔
42	for (; i < 80; ++i)	28,275✔
43	{
44	m[i] = (m[i - 3] ^ m[i - 8] ^ m[i - 14] ^ m[i - 16]);	27,840✔
45	m[i] = (m[i] << 1) \| (m[i] >> 31);	27,840✔
46	}
47
48	a = ctx->state[0];	435✔
49	b = ctx->state[1];	435✔
50	c = ctx->state[2];	435✔
51	d = ctx->state[3];	435✔
52	e = ctx->state[4];	435✔
53
54	for (i = 0; i < 20; ++i)	9,135✔
55	{
56	t = ROTLEFT(a, 5) + ((b & c) ^ (~b & d)) + e + 0x5a827999U + m[i];	8,700✔
57	e = d;	8,700✔
58	d = c;	8,700✔
59	c = ROTLEFT(b, 30);	8,700✔
60	b = a;	8,700✔
61	a = t;	8,700✔
62	}
63	for (; i < 40; ++i)	9,135✔
64	{
65	t = ROTLEFT(a, 5) + (b ^ c ^ d) + e + 0x6ed9eba1U + m[i];	8,700✔
66	e = d;	8,700✔
67	d = c;	8,700✔
68	c = ROTLEFT(b, 30);	8,700✔
69	b = a;	8,700✔
70	a = t;	8,700✔
71	}
72	for (; i < 60; ++i)	9,135✔
73	{
74	t = ROTLEFT(a, 5) + ((b & c) ^ (b & d) ^ (c & d)) + e + 0x8f1bbcdcU +	8,700✔
75	m[i];	8,700✔
76	e = d;	8,700✔
77	d = c;	8,700✔
78	c = ROTLEFT(b, 30);	8,700✔
79	b = a;	8,700✔
80	a = t;	8,700✔
81	}
82	for (; i < 80; ++i)	9,135✔
83	{
84	t = ROTLEFT(a, 5) + (b ^ c ^ d) + e + 0xca62c1d6U + m[i];	8,700✔
85	e = d;	8,700✔
86	d = c;	8,700✔
87	c = ROTLEFT(b, 30);	8,700✔
88	b = a;	8,700✔
89	a = t;	8,700✔
90	}
91
92	ctx->state[0] += a;	435✔
93	ctx->state[1] += b;	435✔
94	ctx->state[2] += c;	435✔
95	ctx->state[3] += d;	435✔
96	ctx->state[4] += e;	435✔
97	}	435✔
98
99	/************************************************************************/
100	/* CPL_SHA1Init() */
101	/************************************************************************/
102
103	static void CPL_SHA1Init(CPL_SHA1Context *ctx)	208✔
104	{
105	ctx->datalen = 0;	208✔
106	ctx->bitlen = 0;	208✔
107	ctx->state[0] = 0x67452301U;	208✔
108	ctx->state[1] = 0xEFCDAB89U;	208✔
109	ctx->state[2] = 0x98BADCFEU;	208✔
110	ctx->state[3] = 0x10325476U;	208✔
111	ctx->state[4] = 0xc3d2e1f0U;	208✔
112	}	208✔
113
114	/************************************************************************/
115	/* CPL_SHA1Update() */
116	/************************************************************************/
117
118	static void CPL_SHA1Update(CPL_SHA1Context *ctx, const GByte data[], size_t len)	416✔
119	{
120	size_t i;
121
122	for (i = 0; i < len; ++i)	21,106✔
123	{
124	ctx->data[ctx->datalen] = data[i];	20,690✔
125	ctx->datalen++;	20,690✔
126	if (ctx->datalen == 64)	20,690✔
127	{
128	sha1_transform(ctx, ctx->data);	222✔
129	ctx->bitlen += 512;	222✔
130	ctx->datalen = 0;	222✔
131	}
132	}
133	}	416✔
134
135	/************************************************************************/
136	/* CPL_SHA1Final() */
137	/************************************************************************/
138
139	static void CPL_SHA1Final(CPL_SHA1Context *ctx, GByte hash[CPL_SHA1_HASH_SIZE])	208✔
140	{
141	GUInt32 i;
142
143	i = ctx->datalen;	208✔
144
145	// Pad whatever data is left in the buffer.
146	if (ctx->datalen < 56)	208✔
147	{
148	ctx->data[i++] = 0x80;	203✔
149	while (i < 56)	5,183✔
150	ctx->data[i++] = 0x00;	4,980✔
151	}
152	else
153	{
154	ctx->data[i++] = 0x80;	5✔
155	while (i < 64)	23✔
156	ctx->data[i++] = 0x00;	18✔
157	sha1_transform(ctx, ctx->data);	5✔
158	memset(ctx->data, 0, 56);	5✔
159	}
160
161	// Append to the padding the total message's length in bits and transform.
162	ctx->bitlen += ctx->datalen * 8;	208✔
163	ctx->data[63] = static_cast<GByte>((ctx->bitlen) & 0xFFU);	208✔
164	ctx->data[62] = static_cast<GByte>((ctx->bitlen >> 8) & 0xFFU);	208✔
165	ctx->data[61] = static_cast<GByte>((ctx->bitlen >> 16) & 0xFFU);	208✔
166	ctx->data[60] = static_cast<GByte>((ctx->bitlen >> 24) & 0xFFU);	208✔
167	ctx->data[59] = static_cast<GByte>((ctx->bitlen >> 32) & 0xFFU);	208✔
168	ctx->data[58] = static_cast<GByte>((ctx->bitlen >> 40) & 0xFFU);	208✔
169	ctx->data[57] = static_cast<GByte>((ctx->bitlen >> 48) & 0xFFU);	208✔
170	ctx->data[56] = static_cast<GByte>((ctx->bitlen >> 56) & 0xFFU);	208✔
171	sha1_transform(ctx, ctx->data);	208✔
172
173	// Since this implementation uses little endian byte ordering and MD uses
174	// big endian, reverse all the bytes when copying the final state to the
175	// output hash.
176	for (i = 0; i < 4; ++i)	1,040✔
177	{
178	hash[i] =	832✔
179	static_cast<GByte>((ctx->state[0] >> (24 - i * 8)) & 0x000000ffU);	832✔
180	hash[i + 4] =	832✔
181	static_cast<GByte>((ctx->state[1] >> (24 - i * 8)) & 0x000000ffU);	832✔
182	hash[i + 8] =	832✔
183	static_cast<GByte>((ctx->state[2] >> (24 - i * 8)) & 0x000000ffU);	832✔
184	hash[i + 12] =	832✔
185	static_cast<GByte>((ctx->state[3] >> (24 - i * 8)) & 0x000000ffU);	832✔
186	hash[i + 16] =	832✔
187	static_cast<GByte>((ctx->state[4] >> (24 - i * 8)) & 0x000000ffU);	832✔
188	}
189	}	208✔
190
191	/************************************************************************/
192	/* CPL_SHA1() */
193	/************************************************************************/
194
195	void CPL_SHA1(const void *data, size_t len, GByte hash[CPL_SHA1_HASH_SIZE])	×
196	{
197	CPL_SHA1Context sSHA1Ctxt;
198	CPL_SHA1Init(&sSHA1Ctxt);	×
199	CPL_SHA1Update(&sSHA1Ctxt, static_cast<const GByte *>(data), len);	×
200	CPL_SHA1Final(&sSHA1Ctxt, hash);	×
201	memset(&sSHA1Ctxt, 0, sizeof(sSHA1Ctxt));	×
202	}	×
203
204	/************************************************************************/
205	/* CPL_HMAC_SHA1() */
206	/************************************************************************/
207
208	#define CPL_HMAC_SHA1_BLOCKSIZE 64U
209
210	// See
211	// https://en.wikipedia.org/wiki/Hash-based_message_authentication_code#Implementation
212	void CPL_HMAC_SHA1(const void pKey, size_t nKeyLen, const void pabyMessage,	104✔
213	size_t nMessageLen, GByte abyDigest[CPL_SHA1_HASH_SIZE])
214	{
215	GByte abyPad[CPL_HMAC_SHA1_BLOCKSIZE] = {};	104✔
216	if (nKeyLen > CPL_HMAC_SHA1_BLOCKSIZE)	104✔
217	{
218	CPL_SHA1(pKey, nKeyLen, abyPad);	×
219	}
220	else
221	{
222	memcpy(abyPad, pKey, nKeyLen);	104✔
223	}
224
225	// Compute ipad.
226	for (size_t i = 0; i < CPL_HMAC_SHA1_BLOCKSIZE; i++)	6,760✔
227	abyPad[i] = 0x36 ^ abyPad[i];	6,656✔
228
229	CPL_SHA1Context sSHA1Ctxt;
230	CPL_SHA1Init(&sSHA1Ctxt);	104✔
231	CPL_SHA1Update(&sSHA1Ctxt, abyPad, CPL_HMAC_SHA1_BLOCKSIZE);	104✔
232	CPL_SHA1Update(&sSHA1Ctxt, static_cast<const GByte *>(pabyMessage),	104✔
233	nMessageLen);
234	CPL_SHA1Final(&sSHA1Ctxt, abyDigest);	104✔
235
236	// Compute opad.
237	for (size_t i = 0; i < CPL_HMAC_SHA1_BLOCKSIZE; i++)	6,760✔
238	abyPad[i] = (0x36 ^ 0x5C) ^ abyPad[i];	6,656✔
239
240	CPL_SHA1Init(&sSHA1Ctxt);	104✔
241	CPL_SHA1Update(&sSHA1Ctxt, abyPad, CPL_HMAC_SHA1_BLOCKSIZE);	104✔
242	CPL_SHA1Update(&sSHA1Ctxt, abyDigest, CPL_SHA1_HASH_SIZE);	104✔
243	CPL_SHA1Final(&sSHA1Ctxt, abyDigest);	104✔
244
245	memset(&sSHA1Ctxt, 0, sizeof(sSHA1Ctxt));	104✔
246	memset(abyPad, 0, CPL_HMAC_SHA1_BLOCKSIZE);	104✔
247	}	104✔

OSGeo / gdal / 13813968540

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous