Extern/Beef
1
0
Fork 0
mirror of https://github.com/beefytech/Beef.git synced 2025-06-18 08:06:04 +02:00
Code Activity

Moving corlib files out of "System" directory into root

Browse source
This commit is contained in:
Brian Fiete 2019-09-19 05:46:35 -07:00
parent 4cd58262e4
commit 7dbfd15292
179 changed files with 3 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

309
BeefLibs/corlib/src/Security/Cryptography/MD5.bf Normal file
View file

@ -0,0 +1,309 @@
namespace System.Security.Cryptography
{
struct MD5Hash
{
public uint8[16] mHash;
public static Result<MD5Hash> Parse(StringView str)
{
if (str.Length != 32)
return .Err;
MD5Hash hash = ?;
Result<uint8> ParseChar(char8 c)
{
if ((c >= '0') && (c <= '9'))
return (uint8)(c - '0');
if ((c >= 'A') && (c <= 'F'))
return (uint8)(c - 'A' + 10);
if ((c >= 'a') && (c <= 'f'))
return (uint8)(c - 'a' + 10);
return .Err;
}
for (int i < 16)
{
hash.mHash[i] =
(Try!(ParseChar(str[i * 2 + 0])) << 4) |
(Try!(ParseChar(str[i * 2 + 1])));
}
return hash;
}
public bool IsZero
{
get
{
for (int i < 16)
if (mHash[i] != 0)
return false;
return true;
}
}
public override void ToString(String strBuffer)
{
for (let val in mHash)
{
val.ToString(strBuffer, "X2", null);
}
}
}
class MD5
{
uint32 lo, hi;
uint32 a, b, c, d;
uint8[64] buffer;
uint32[16] block;
public this()
{
a = 0x67452301;
b = 0xefcdab89;
c = 0x98badcfe;
d = 0x10325476;
lo = 0;
hi = 0;
}
uint8* Body(Span<uint8> data)
{
// The basic MD5 functions.
uint8* ptr = data.Ptr;
int size = data.Length;
// F and G are optimized compared to their RFC 1321 definitions for
// architectures that lack an AND-NOT instruction, just like in Colin Plumb's
// implementation.
mixin F(var x, var y, var z) { ((z) ^ ((x) & ((y) ^ (z)))) }
mixin G(var x, var y, var z) { ((y) ^ ((z) & ((x) ^ (y)))) }
mixin H(var x, var y, var z) { ((x) ^ (y) ^ (z)) }
mixin I(var x, var y, var z) { ((y) ^ ((x) | ~(z))) }
// The MD5 transformation for all four rounds.
mixin STEP_F(var a, var b, var c, var d, var x, var t, var s)
{
a += F!(b, c, d) + x + t;
a = ((a << s) | ((a & 0xffffffff) >> (32 - s)));
a += b;
}
mixin STEP_G(var a, var b, var c, var d, var x, var t, var s)
{
a += G!(b, c, d) + x + t;
a = ((a << s) | ((a & 0xffffffff) >> (32 - s)));
a += b;
}
mixin STEP_H(var a, var b, var c, var d, var x, var t, var s)
{
a += H!(b, c, d) + x + t;
a = ((a << s) | ((a & 0xffffffff) >> (32 - s)));
a += b;
}
mixin STEP_I(var a, var b, var c, var d, var x, var t, var s)
{
a += I!(b, c, d) + x + t;
a = ((a << s) | ((a & 0xffffffff) >> (32 - s)));
a += b;
}
// SET reads 4 input bytes in little-endian byte order and stores them
// in a properly aligned word in host byte order.
mixin SET(var n)
{
block[n] =
(uint32)ptr[n * 4] |
((uint32)ptr[n * 4 + 1] << 8) |
((uint32)ptr[n * 4 + 2] << 16) |
((uint32)ptr[n * 4 + 3] << 24)
}
mixin GET(var n) { block[n] }
a = this.a;
b = this.b;
c = this.c;
d = this.d;
repeat
{
let saved_a = a;
let saved_b = b;
let saved_c = c;
let saved_d = d;
// Round 1
STEP_F!(a, b, c, d, SET!(0), 0xd76aa478, 7);
STEP_F!(d, a, b, c, SET!(1), 0xe8c7b756, 12);
STEP_F!(c, d, a, b, SET!(2), 0x242070db, 17);
STEP_F!(b, c, d, a, SET!(3), 0xc1bdceee, 22);
STEP_F!(a, b, c, d, SET!(4), 0xf57c0faf, 7);
STEP_F!(d, a, b, c, SET!(5), 0x4787c62a, 12);
STEP_F!(c, d, a, b, SET!(6), 0xa8304613, 17);
STEP_F!(b, c, d, a, SET!(7), 0xfd469501, 22);
STEP_F!(a, b, c, d, SET!(8), 0x698098d8, 7);
STEP_F!(d, a, b, c, SET!(9), 0x8b44f7af, 12);
STEP_F!(c, d, a, b, SET!(10), 0xffff5bb1, 17);
STEP_F!(b, c, d, a, SET!(11), 0x895cd7be, 22);
STEP_F!(a, b, c, d, SET!(12), 0x6b901122, 7);
STEP_F!(d, a, b, c, SET!(13), 0xfd987193, 12);
STEP_F!(c, d, a, b, SET!(14), 0xa679438e, 17);
STEP_F!(b, c, d, a, SET!(15), 0x49b40821, 22);
// Round 2
STEP_G!(a, b, c, d, GET!(1), 0xf61e2562, 5);
STEP_G!(d, a, b, c, GET!(6), 0xc040b340, 9);
STEP_G!(c, d, a, b, GET!(11), 0x265e5a51, 14);
STEP_G!(b, c, d, a, GET!(0), 0xe9b6c7aa, 20);
STEP_G!(a, b, c, d, GET!(5), 0xd62f105d, 5);
STEP_G!(d, a, b, c, GET!(10), 0x02441453, 9);
STEP_G!(c, d, a, b, GET!(15), 0xd8a1e681, 14);
STEP_G!(b, c, d, a, GET!(4), 0xe7d3fbc8, 20);
STEP_G!(a, b, c, d, GET!(9), 0x21e1cde6, 5);
STEP_G!(d, a, b, c, GET!(14), 0xc33707d6, 9);
STEP_G!(c, d, a, b, GET!(3), 0xf4d50d87, 14);
STEP_G!(b, c, d, a, GET!(8), 0x455a14ed, 20);
STEP_G!(a, b, c, d, GET!(13), 0xa9e3e905, 5);
STEP_G!(d, a, b, c, GET!(2), 0xfcefa3f8, 9);
STEP_G!(c, d, a, b, GET!(7), 0x676f02d9, 14);
STEP_G!(b, c, d, a, GET!(12), 0x8d2a4c8a, 20);
// Round 3
STEP_H!( a, b, c, d, GET!(5), 0xfffa3942, 4);
STEP_H!( d, a, b, c, GET!(8), 0x8771f681, 11);
STEP_H!( c, d, a, b, GET!(11), 0x6d9d6122, 16);
STEP_H!( b, c, d, a, GET!(14), 0xfde5380c, 23);
STEP_H!( a, b, c, d, GET!(1), 0xa4beea44, 4);
STEP_H!( d, a, b, c, GET!(4), 0x4bdecfa9, 11);
STEP_H!( c, d, a, b, GET!(7), 0xf6bb4b60, 16);
STEP_H!( b, c, d, a, GET!(10), 0xbebfbc70, 23);
STEP_H!( a, b, c, d, GET!(13), 0x289b7ec6, 4);
STEP_H!( d, a, b, c, GET!(0), 0xeaa127fa, 11);
STEP_H!( c, d, a, b, GET!(3), 0xd4ef3085, 16);
STEP_H!( b, c, d, a, GET!(6), 0x04881d05, 23);
STEP_H!( a, b, c, d, GET!(9), 0xd9d4d039, 4);
STEP_H!( d, a, b, c, GET!(12), 0xe6db99e5, 11);
STEP_H!( c, d, a, b, GET!(15), 0x1fa27cf8, 16);
STEP_H!( b, c, d, a, GET!(2), 0xc4ac5665, 23);
// Round 4
STEP_I!(a, b, c, d, GET!(0), 0xf4292244, 6);
STEP_I!(d, a, b, c, GET!(7), 0x432aff97, 10);
STEP_I!(c, d, a, b, GET!(14), 0xab9423a7, 15);
STEP_I!(b, c, d, a, GET!(5), 0xfc93a039, 21);
STEP_I!(a, b, c, d, GET!(12), 0x655b59c3, 6);
STEP_I!(d, a, b, c, GET!(3), 0x8f0ccc92, 10);
STEP_I!(c, d, a, b, GET!(10), 0xffeff47d, 15);
STEP_I!(b, c, d, a, GET!(1), 0x85845dd1, 21);
STEP_I!(a, b, c, d, GET!(8), 0x6fa87e4f, 6);
STEP_I!(d, a, b, c, GET!(15), 0xfe2ce6e0, 10);
STEP_I!(c, d, a, b, GET!(6), 0xa3014314, 15);
STEP_I!(b, c, d, a, GET!(13), 0x4e0811a1, 21);
STEP_I!(a, b, c, d, GET!(4), 0xf7537e82, 6);
STEP_I!(d, a, b, c, GET!(11), 0xbd3af235, 10);
STEP_I!(c, d, a, b, GET!(2), 0x2ad7d2bb, 15);
STEP_I!(b, c, d, a, GET!(9), 0xeb86d391, 21);
a += saved_a;
b += saved_b;
c += saved_c;
d += saved_d;
ptr += 64;
}
while ((size -= 64) > 0);
this.a = a;
this.b = b;
this.c = c;
this.d = d;
return ptr;
}
public void Update(Span<uint8> span)
{
uint32 saved_lo;
uint32 used, free;
uint8* ptr = span.Ptr;
uint32 size = (uint32)span.Length;
saved_lo = lo;
if ((lo = (saved_lo + size) & 0x1fffffff) < saved_lo)
hi++;
hi += size >> 29;
used = saved_lo & 0x3f;
if (used != 0)
{
free = 64 - used;
if (size < free)
{
Internal.MemCpy(&buffer[used], ptr, (.)size);
return;
}
Internal.MemCpy(&buffer[used], ptr, (.)free);
ptr = ptr + free;
size -= free;
Body(Span<uint8>(&buffer[0], 64));
}
if (size >= 64)
{
ptr = Body(Span<uint8>(ptr, (.)(size & ~(uint32)0x3f)));
size &= 0x3f;
}
Internal.MemCpy(&buffer[0], ptr, (.)size);
}
public MD5Hash Finish()
{
uint32 used, free;
used = lo & 0x3f;
buffer[used++] = 0x80;
free = 64 - used;
if (free < 8)
{
if (free > 0)
Internal.MemSet(&buffer[used], 0, (.)free);
Body(Span<uint8>(&buffer[0], 64));
used = 0;
free = 64;
}
Internal.MemSet(&buffer[used], 0, (.)free - 8);
lo <<= 3;
LittleEndian.Write(&buffer[56], lo);
LittleEndian.Write(&buffer[60], hi);
Body(Span<uint8>(&buffer[0], 64));
MD5Hash hash = ?;
LittleEndian.Write(&hash.mHash[0], a);
LittleEndian.Write(&hash.mHash[4], b);
LittleEndian.Write(&hash.mHash[8], c);
LittleEndian.Write(&hash.mHash[12], d);
return hash;
}
public static MD5Hash Hash(Span<uint8> data)
{
let md5 = scope MD5();
md5.Update(data);
return md5.Finish();
}
}
}

232
BeefLibs/corlib/src/Security/Cryptography/SHA256.bf Normal file
View file

@ -0,0 +1,232 @@
namespace System.Security.Cryptography
{
struct SHA256Hash
{
public uint8[32] mHash;
public static Result<SHA256Hash> Parse(StringView str)
{
if (str.Length != 64)
return .Err;
SHA256Hash hash = ?;
Result<uint8> ParseChar(char8 c)
{
if ((c >= '0') && (c <= '9'))
return (uint8)(c - '0');
if ((c >= 'A') && (c <= 'F'))
return (uint8)(c - 'A' + 10);
if ((c >= 'a') && (c <= 'f'))
return (uint8)(c - 'a' + 10);
return .Err;
}
for (int i < 32)
{
hash.mHash[i] =
(Try!(ParseChar(str[i * 2 + 0])) << 4) |
(Try!(ParseChar(str[i * 2 + 1])));
}
return hash;
}
public bool IsZero
{
get
{
for (int i < 32)
if (mHash[i] != 0)
return false;
return true;
}
}
}
struct SHA256
{
int mDataLen;
int mBitLength;
uint32[8] mState;
uint8[64] mData;
mixin ROTLEFT(var a,var b)
{
(((a) << (b)) | ((a) >> (32-(b))))
}
mixin ROTRIGHT(var a, var b)
{
(((a) >> (b)) | ((a) << (32-(b))))
}
mixin CH(var x, var y, var z)
{
(((x) & (y)) ^ (~(x) & (z)))
}
mixin MAJ(var x, var y, var z)
{
(((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
}
mixin EP0(var x)
{
(ROTRIGHT!(x,2) ^ ROTRIGHT!(x,13) ^ ROTRIGHT!(x,22))
}
mixin EP1(var x)
{
(ROTRIGHT!(x,6) ^ ROTRIGHT!(x,11) ^ ROTRIGHT!(x,25))
}
mixin SIG0(var x)
{
(ROTRIGHT!(x,7) ^ ROTRIGHT!(x,18) ^ ((x) >> 3))
}
mixin SIG1(var x)
{
(ROTRIGHT!(x,17) ^ ROTRIGHT!(x,19) ^ ((x) >> 10))
}
const uint32[64] k = (
0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5,0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5,
0xd807aa98,0x12835b01,0x243185be,0x550c7dc3,0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174,
0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc,0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da,
0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7,0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967,
0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13,0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85,
0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3,0xd192e819,0xd6990624,0xf40e3585,0x106aa070,
0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5,0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3,
0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2
);
public this()
{
mDataLen = 0;
mBitLength = 0;
mState[0] = 0x6a09e667;
mState[1] = 0xbb67ae85;
mState[2] = 0x3c6ef372;
mState[3] = 0xa54ff53a;
mState[4] = 0x510e527f;
mState[5] = 0x9b05688c;
mState[6] = 0x1f83d9ab;
mState[7] = 0x5be0cd19;
mData = .(?);
}
void Transform() mut
{
uint32 a, b, c, d, e, f, g, h, i, j, t1, t2;
uint32[64] m = ?;
for (i = 0, j = 0; i < 16; ++i, j += 4)
m[i] = ((uint32)mData[j] << 24) | ((uint32)mData[j + 1] << 16) | ((uint32)mData[j + 2] << 8) | ((uint32)mData[j + 3]);
for ( ; i < 64; ++i)
m[i] = SIG1!(m[i - 2]) + m[i - 7] + SIG0!(m[i - 15]) + m[i - 16];
a = mState[0];
b = mState[1];
c = mState[2];
d = mState[3];
e = mState[4];
f = mState[5];
g = mState[6];
h = mState[7];
for (i = 0; i < 64; ++i)
{
t1 = h + EP1!(e) + CH!(e,f,g) + k[i] + m[i];
t2 = EP0!(a) + MAJ!(a,b,c);
h = g;
g = f;
f = e;
e = d + t1;
d = c;
c = b;
b = a;
a = t1 + t2;
}
mState[0] += a;
mState[1] += b;
mState[2] += c;
mState[3] += d;
mState[4] += e;
mState[5] += f;
mState[6] += g;
mState[7] += h;
}
public void Update(Span<uint8> data) mut
{
for (int i = 0; i < data.Length; ++i)
{
mData[mDataLen] = data[i];
mDataLen++;
if (mDataLen == 64)
{
Transform();
mBitLength += 512;
mDataLen = 0;
}
}
}
public SHA256Hash Finish() mut
{
int i = mDataLen;
// Pad whatever data is left in the buffer.
if (mDataLen < 56)
{
mData[i++] = 0x80;
while (i < 56)
mData[i++] = 0x00;
}
else
{
mData[i++] = 0x80;
while (i < 64)
mData[i++] = 0x00;
Transform();
Internal.MemSet(&mData, 0, 56);
}
// Append to the padding the total message's length in bits and transform.
mBitLength += mDataLen * 8;
int64 bitLength = mBitLength;
mData[63] = (.)bitLength;
mData[62] = (.)(bitLength >> 8);
mData[61] = (.)(bitLength >> 16);
mData[60] = (.)(bitLength >> 24);
mData[59] = (.)(bitLength >> 32);
mData[58] = (.)(bitLength >> 40);
mData[57] = (.)(bitLength >> 48);
mData[56] = (.)(bitLength >> 56);
Transform();
SHA256Hash hash = ?;
// Since this implementation uses little endian byte ordering and SHA uses big endian,
// reverse all the bytes when copying the final state to the output hash.
for (i = 0; i < 4; ++i)
{
hash.mHash[i] = (.)(mState[0] >> (24 - i * 8));
hash.mHash[i + 4] = (.)(mState[1] >> (24 - i * 8));
hash.mHash[i + 8] = (.)(mState[2] >> (24 - i * 8));
hash.mHash[i + 12] = (.)(mState[3] >> (24 - i * 8));
hash.mHash[i + 16] = (.)(mState[4] >> (24 - i * 8));
hash.mHash[i + 20] = (.)(mState[5] >> (24 - i * 8));
hash.mHash[i + 24] = (.)(mState[6] >> (24 - i * 8));
hash.mHash[i + 28] = (.)(mState[7] >> (24 - i * 8));
}
return hash;
}
public static SHA256Hash Hash(Span<uint8> data)
{
let sha256 = scope SHA256();
sha256.Update(data);
return sha256.Finish();
}
}
}