ANSCENTER/ANSCORE
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor project structure

Browse Source
This commit is contained in:
Tuan Nghia Nguyen
2026-03-28 19:56:39 +11:00
parent 1d267378b2
commit 8a2e721058
511 changed files with 59 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files

378
core/anslicensing/base64.cpp Normal file
View File

@@ -0,0 +1,378 @@
#include "precomp.h"
#include <cstdlib>
#include <string>
#include <cassert>
#include "base64.h"
using namespace std;
/*
* The Base 64 Alphabet
*
* Value Encoding Value Encoding Value Encoding Value Encoding
* 0 A 17 R 34 i 51 z
* 1 B 18 S 35 j 52 0
* 2 C 19 T 36 k 53 1
* 3 D 20 U 37 l 54 2
* 4 E 21 V 38 m 55 3
* 5 F 22 W 39 n 56 4
* 6 G 23 X 40 o 57 5
* 7 H 24 Y 41 p 58 6
* 8 I 25 Z 42 q 59 7
* 9 J 26 a 43 r 60 8
* 10 K 27 b 44 s 61 9
* 11 L 28 c 45 t 62 +
* 12 M 29 d 46 u 63 /
* 13 N 30 e 47 v
* 14 O 31 f 48 w (pad) =
* 15 P 32 g 49 x
* 16 Q 33 h 50 y
*/
const char BASE64::alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const char BASE64::values[] = {
/* 0 1 2 3 4 5 6 7 8 9 */ /* 0123456789 */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* - 00 -> 09 */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* - 10 -> 19 */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* - 20 -> 29 */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* - 30 -> 39 */
-1,-1,-1,62,-1,-1,-1,63, /* ()*+'-./ - 40 -> 47 */
52,53,54,55,56,57,58,59,60,61, /* 0123456789 - 48 -> 57 */
-1,-1,-1,-1,-1,-1,-1, 0, 1, 2, /* :;<=>?@ABC - 58 -> 67 */
3, 4, 5, 6, 7, 8, 9,10,11,12, /* DEFGHIJKLM - 68 -> 77 */
13,14,15,16,17,18,19,20,21,22, /* NOPQRSTUVW - 78 -> 87 */
23,24,25,-1,-1,-1,-1,-1,-1,26, /* XYZ[\]^_`a - 88 -> 97 */
27,28,29,30,31,32,33,34,35,36, /* bcdefghijk - 98 -> 107 */
37,38,39,40,41,42,43,44,45,46, /* lmnopqrstu - 108 -> 117 */
47,48,49,50,51, /* vwxyz - 118 -> 122 */
-1,-1,-1,-1,-1,-1,-1,-1, /* - 123 -> 130 */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* - 131 -> 140 */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* - 141 -> 150 */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* - 151 -> 160 */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* - 161 -> 170 */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* - 171 -> 180 */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* - 181 -> 190 */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* - 191 -> 200 */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* - 201 -> 210 */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* - 211 -> 220 */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* - 221 -> 230 */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* - 231 -> 240 */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* - 241 -> 250 */
-1,-1,-1,-1,-1, /* - 251 -> 255 */
};
BASE64::BASE64()
{
}
BASE64::~BASE64()
{
}
string BASE64::encode(unsigned char * buf, int len, bool padding)
{
int pad;
int enclen = encode_pad_length(len, &pad);
string encbuf;
if (!padding)
pad = 0;
encbuf.resize(enclen + pad); /* Allow for trailing NUL */
encode_exactly(buf, len, encbuf.data(), enclen);
if (pad)
memset(encbuf.data() + enclen, '=', pad);
return encbuf;
}
/**
* encode_exactly
*
* Encode `len' bytes from `buf' unsignedo `enclen' bytes starting from `encbuf'.
* Caller must have ensured that there was EXACTLY the needed room in encbuf.
*/
void BASE64::encode_exactly(const unsigned char *buf, int len, char *encbuf, int enclen)
{
int i = 0; /* Input accumulator, 0 for trailing pad */
unsigned char const *ip = buf + len; /* Input pounsigneder, one byte off end */
char *op = encbuf + enclen; /* Output pounsigneder, one byte off end */
assert(buf);
assert(encbuf);
assert(len > 0);
assert(enclen >= len * 4 / 3);
/*
* In the following picture, we represent how the 3 bytes of input
* are split unsignedo groups of 6 bits, each group being encoded as a
* single base64 digit.
*
* input byte 0 1 2
* +--------+--------+--------+
* |01234501|23450123|45012345|
* +--------+--------+--------+
* <----><-----><-----><---->
* output digit 0 1 2 3
*
*
* Because of possible padding, which must be done as if the input
* was 0, and because the fractional part is at the end, we'll
* start encoding from the end. The encoding loop is unrolled for
* greater performance (using the infamous Duff's device to directly
* switch at the proper stage within the do {} while loop).
*/
switch (len % 3) {
case 0:
do {
assert(op - encbuf >= 4);
i = (unsigned char) *--ip; /* Input #2 */
*--op = alphabet[i & 0x3f]; /* Ouput #3 */
i >>= 6; /* upper <45>, input #2 */
/* FALLTHROUGH */
case 2:
i |= ((unsigned char) *--ip) << 2; /* had 2 bits in `i' */
*--op = alphabet[i & 0x3f]; /* Output #2 */
i >>= 6; /* upper <2345>, input #1 */
/* FALLTHROUGH */
case 1:
i |= ((unsigned char) *--ip) << 4; /* had 4 bits in `i' */
*--op = alphabet[i & 0x3f]; /* Output #1 */
i >>= 6; /* upper <012345>, input #0 */
*--op = alphabet[i & 0x3f]; /* Output #0 */
i >>= 6; /* Holds nothing, MBZ */
assert(i == 0);
assert(op >= encbuf);
} while (op > encbuf);
}
}
/**
* encode_pad_length
*
* Compute the number of base64 digits and amount of padding necessary
* to encode `len' bytes.
*
* Returns the number of base64 digits necessary.
* Furthermore, if `pad' is a non-NULL pounsigneder, it is filled with the amount
* of padding chars that would be necessary.
*/
int BASE64::encode_pad_length(int len, int *pad)
{
int ndigits; /* Base64 digits necessary */
int npad = 0; /* Final padding chars necessary */
int tcount; /* Amount of full triplets */
int remainder; /* Amount of input bytes in final triplet */
assert(len > 0);
tcount = len / 3;
remainder = len - (tcount * 3);
assert((unsigned) remainder >= 0);
switch (remainder) {
case 0: npad = 0; break;
case 1: npad = 2; break;
case 2: npad = 1; break;
default: assert(0); /* Not possible */
}
ndigits = tcount * 4; /* Each full triplet encoded on 4 bytes */
if (npad != 0)
ndigits += (4 - npad);
if (pad)
*pad = npad;
return ndigits;
}
/**
* base64_decode
*
* Decode `len' bytes starting at `buf' unsignedo new allocated buffer.
*
* Returns the new decoded buffer, or NULL if the input was not valid base64
* encoding. The caller knows the length of the returned buffer: it's the
* size of the input divided by 4 and multiplied by 3. If `outlen' is non-NULL,
* it is filled with the amount of bytes decoded unsignedo the buffer (without
* trailing padding).
*/
vector<unsigned char> BASE64::decode(const char * buf, int len, int * outlen)
{
int declen;
vector<unsigned char> decbuf;
int decoded;
if (len == -1)
len = strlen(buf);
// if (len == 0 || (len & 0x3)) /* Empty, or padding bytes missing */
// return NULL;
declen = (len >> 2) * 3;
decbuf.resize(declen * sizeof(unsigned char));
decoded = decode_into(buf, len, decbuf.data(), declen);
if (decoded == 0)
decbuf.clear();
if (outlen)
*outlen = decoded;
return decbuf;
}
/**
* decode_into
*
* Decode `len' bytes from `buf' unsignedo `declen' bytes starting from `decbuf',
* faking the necessary amount of padding if necessary.
* Caller must have ensured that there was sufficient room in decbuf.
*
* Returns the amount of bytes decoded (without trailing padding) if successful,
* 0 if the input was not valid base32.
*/
int BASE64::decode_into(const char *buf, int len, unsigned char *decbuf, int declen)
{
int padding = 0;
if (len & 0x3)
padding = 4 - (len & 0x3);
return decode_alphabet(values, buf, len + padding, decbuf, declen, padding);
}
/*
* decode_alphabet
*
* Decode `len' bytes from `buf' unsignedo `declen' bytes starting from `decbuf'.
* Caller must have ensured that there was sufficient room in decbuf.
* Uses the specified decoding alphabet.
*
* `padding', when non-zero, is the amount of padding that is missing from
* the input buffer and which we must assume.
*
* Return decoded bytes if successful, 0 if the input was not valid base32.
*/
int BASE64::decode_alphabet(const char valmap[],
const char *buf, int len, unsigned char *decbuf, int declen, int padding)
{
int i = 0; /* Input accumulator, 0 for trailing pad */
char const *ip = buf + len; /* Input pounsigneder, one byte off end */
int dlen = (len >> 2) * 3; /* Exact decoded length */
unsigned char *op; /* Output pounsigneder, one byte off end */
int bytes; /* Bytes decoded without padding */
char v;
assert(buf);
assert(decbuf);
assert(len > 0);
assert((len & 0x3) == 0); /* `len' is a multiple of 4 bytes */
//assert(declen >= dlen);
/*
* If the last byte of input is '=', there is padding and we need to
* zero the tail of the decoding buffer.
*
* Likewise, when `padding' is non-zero, act as if the '=' were there.
*/
if (buf[len-1] == '=' || padding > 0) {
int pad = 0;
int n = 0; /* Amount of bytes to zero */
int s = 0; /* Amount of bytes to zero */
/*
* Remove and count trailing input padding bytes.
*/
if (padding == 0) {
while (*--ip == '=')
pad++;
ip++; /* Pounsigneds one byte after real non-padding input */
} else {
pad = padding;
ip -= padding;
}
switch (pad) {
case 1: n = 1; s = 0; break;
case 2: n = 2; s = 1; break;
default:
return 0; /* Cannot be valid base64 */
}
memset(decbuf + (dlen - n), 0, n);
op = decbuf + (dlen - s);
bytes = dlen - n;
} else {
op = decbuf + dlen;
bytes = dlen;
}
/*
* In the following picture, we represent how the 4 bytes of input,
* each consisting of only 6 bits of information forming a base64 digit,
* are concatenated back unsignedo 3 bytes of binary information.
*
* input digit 0 1 2 3
* <----><-----><-----><---->
* +--------+--------+--------+
* |01234501|23450123|45012345|
* +--------+--------+--------+
* output byte 0 1 2
*
* Because of possible padding, which must be done as if the input
* was 0, and because the fractional part is at the end, we'll
* start decoding from the end. The decoding loop is unrolled for
* greater performance (using the infamous Duff's device to directly
* switch at the proper stage within the do {} while loop).
*/
switch ((ip - buf) % 4) {
case 0:
do {
v = valmap[(unsigned char) *--ip]; /* Input #3 */
if (v < 0) return 0;
i = v;
/* FALLTHROUGH */
case 3:
v = valmap[(unsigned char) *--ip]; /* Input #2 */
if (v < 0) return 0;
i |= v << 6; /* had 6 bits */
*--op = i & 0xff; /* Output #2 */
i >>= 8; /* lower <0123> of output #1 */
/* FALLTHROUGH */
case 2:
v = valmap[(unsigned char) *--ip]; /* Input #1 */
if (v < 0) return 0;
i |= v << 4; /* had 4 bits */
*--op = i & 0xff; /* Output #1 */
i >>= 8; /* lower <01> of output #0 */
/* FALLTHROUGH */
case 1:
v = valmap[(unsigned char) *--ip]; /* Input #0 */
if (v < 0) return 0;
i |= v << 2; /* had 2 bits */
*--op = i & 0xff; /* Output #0 */
i >>= 8; /* Holds nothing, MBZ */
assert(i == 0);
assert(op >= decbuf);
} while (op > decbuf);
}
return bytes;
}