Skip to content

Chacha #3

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
TurkeyMan wants to merge 2 commits into from
Closed

Chacha #3

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
64bb371
Add main function
TurkeyMan Aug 17, 2025
210a2dc
Added ChaCha stream cypher
TurkeyMan Aug 17, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
19 changes: 2 additions & 17 deletions Makefile
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -22,11 +22,7 @@ DEPFILE := $(OBJDIR)/$(TARGETNAME).d

DFLAGS := $(DFLAGS) -preview=bitfields -preview=rvaluerefparam -preview=nosharedaccess -preview=in

ifeq ($(OS),windows)
SOURCES := $(shell dir /s /b $(SRCDIR)\\*.d)
else
SOURCES := $(shell find "$(SRCDIR)" -type f -name '*.d')
endif

# Set target file based on build type and OS
ifeq ($(BUILD_TYPE),exe)
Expand Down Expand Up @@ -93,30 +89,19 @@ else
endif

ifeq ($(CONFIG),unittest)
DFLAGS := $(DFLAGS) -unittest
DFLAGS := $(DFLAGS) -unittest -main
endif

-include $(DEPFILE)

$(TARGET):
ifeq ($(OS),windows)
@if not exist "obj" mkdir "obj" > nul 2>&1
@if not exist "$(subst /,\,$(OBJDIR))" mkdir "$(subst /,\,$(OBJDIR))" > nul 2>&1
@if not exist "bin" mkdir "bin" > nul 2>&1
@if not exist "$(subst /,\,$(TARGETDIR))" mkdir "$(subst /,\,$(TARGETDIR))" > nul 2>&1
else
mkdir -p $(OBJDIR) $(TARGETDIR)
endif
ifeq ($(D_COMPILER),ldc)
"$(DC)" $(DFLAGS) $(BUILD_CMD_FLAGS) -of$(TARGET) -od$(OBJDIR) -deps=$(DEPFILE) $(SOURCES)
else ifeq ($(D_COMPILER),dmd)
ifeq ($(BUILD_TYPE),lib)
"$(DC)" $(DFLAGS) $(BUILD_CMD_FLAGS) -of$(notdir $(TARGET)) -od$(OBJDIR) -makedeps $(SOURCES) > $(DEPFILE)
ifeq ($(OS),windows)
move "$(subst /,\,$(OBJDIR))\\$(notdir $(TARGET))" "$(subst /,\,$(TARGETDIR))" > nul
else
"$(DC)" $(DFLAGS) $(BUILD_CMD_FLAGS) -of$(OBJDIR)/$(notdir $(TARGET)) -od$(OBJDIR) -makedeps $(SOURCES) > $(DEPFILE)
mv "$(OBJDIR)/$(notdir $(TARGET))" "$(TARGETDIR)"
endif
else # exe
"$(DC)" $(DFLAGS) $(BUILD_CMD_FLAGS) -of$(TARGET) -od$(OBJDIR) -makedeps $(SOURCES) > $(DEPFILE)
endif
Expand Down
299 changes: 299 additions & 0 deletions src/urt/crypto/chacha.d
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,299 @@
module urt.crypto.chacha;

import urt.endian : littleEndianToNative, nativeToLittleEndian;
import urt.mem;

nothrow @nogc:


struct ChaChaContext
{
uint[16] state;
union {
uint[16] keystream32;
ubyte[64] keystream8;
}
uint nonceLow;
ushort position;
ushort rounds;
}


void chacha_init_context(ref ChaChaContext ctx, ref const ubyte[16] key, ulong nonce, ulong counter = 0, uint rounds = 20) pure
{
chacha_init_context(ctx, key, expandNonce(nonce), counter, rounds);
}

void chacha_init_context(ref ChaChaContext ctx, ref const ubyte[32] key, ulong nonce, ulong counter = 0, uint rounds = 20) pure
{
chacha_init_context(ctx, key, expandNonce(nonce), counter, rounds);
}

void chacha_init_context(ref ChaChaContext ctx, ref const ubyte[16] key, ref const ubyte[12] nonce, ulong counter = 0, uint rounds = 20) pure
{
ubyte[32] key256 = void;
key256[0 .. 16] = key[];
key256[16 .. 32] = key[];
chacha_init_context(ctx, key256, nonce, counter, rounds);
}

void chacha_init_context(ref ChaChaContext ctx, ref const ubyte[32] key, ref const ubyte[12] nonce, ulong counter = 0, uint rounds = 20) pure
{
// the number of rounds must be 8, 12 or 20
assert (rounds == 8 || rounds == 12 || rounds == 20);
ctx.rounds = cast(ushort)rounds / 2;

ctx.nonceLow = nonce[0..4].littleEndianToNative!uint;

// the string "expand 32-byte k" in little-endian
enum uint[4] magic_constant = [ 0x61707865, 0x3320646e, 0x79622d32, 0x6b206574 ];

ctx.state[0] = magic_constant[0];
ctx.state[1] = magic_constant[1];
ctx.state[2] = magic_constant[2];
ctx.state[3] = magic_constant[3];
ctx.state[4] = key[0..4].littleEndianToNative!uint;
ctx.state[5] = key[4..8].littleEndianToNative!uint;
ctx.state[6] = key[8..12].littleEndianToNative!uint;
ctx.state[7] = key[12..16].littleEndianToNative!uint;
ctx.state[8] = key[16..20].littleEndianToNative!uint;
ctx.state[9] = key[20..24].littleEndianToNative!uint;
ctx.state[10] = key[24..28].littleEndianToNative!uint;
ctx.state[11] = key[28..32].littleEndianToNative!uint;
ctx.state[12] = cast(uint)counter;
ctx.state[13] = ctx.nonceLow | (counter >> 32);
ctx.state[14] = nonce[4..8].littleEndianToNative!uint;
ctx.state[15] = nonce[8..12].littleEndianToNative!uint;

ctx.keystream32[] = 0;

// set starting position to the end of the key buffer; there are no bytes to consume yet
ctx.position = 64;
}

static void chacha_set_counter(ref ChaChaContext ctx, ulong counter) pure
{
ctx.state[12] = cast(uint)counter;
ctx.state[13] = ctx.nonceLow | (counter >> 32);
}

void chacha_free_context(ref ChaChaContext ctx) pure
{
ctx.state[] = 0;
ctx.keystream32[] = 0;
ctx.position = 0;
ctx.nonceLow = 0;
ctx.rounds = 0;
}

size_t chacha_update(ref ChaChaContext ctx, const ubyte[] input, ubyte[] output) pure
{
import urt.util : min;

size_t size = input.length;
assert(output.length >= size);

size_t offset = 0;
if (ctx.position < 64)
{
size_t startBytes = min(size, 64 - ctx.position);
output[0 .. startBytes] = input[0 .. startBytes] ^ ctx.keystream8[ctx.position .. 64];
ctx.position += startBytes;
size -= startBytes;
offset = startBytes;
}
while (size >= 64)
{
chacha_block_next(ctx);
output[offset .. offset + 64] = input[offset .. offset + 64] ^ ctx.keystream8[];
offset += 64;
size -= 64;
}
if (size > 0)
{
chacha_block_next(ctx);
output[offset .. offset + size] = input[offset .. offset + size] ^ ctx.keystream8[0 .. size];
ctx.position = cast(ushort)size;
}

return input.length;
}


size_t chacha_crypt(const ubyte[] input, ubyte[] output, ref const ubyte[32] key, ulong nonce, ulong counter = 0) pure
{
return chacha_crypt(input, output, key, expandNonce(nonce), counter);
}

size_t chacha_crypt(const ubyte[] input, ubyte[] output, ref const ubyte[32] key, ref const ubyte[12] nonce, ulong counter = 0) pure
{
assert(output.length >= input.length);

ChaChaContext ctx;
ctx.chacha_init_context(key, nonce, counter);
size_t r = ctx.chacha_update(input, output);
ctx.chacha_free_context();
return r;
}


private:

ubyte[12] expandNonce(ulong nonce) pure
{
ubyte[12] nonceBytes = void;
nonceBytes[0 .. 4] = 0;
nonceBytes[4 .. 12] = nativeToLittleEndian(nonce);
return nonceBytes;
}

pragma(inline, true)
uint rotl32(int n)(uint x) pure
=> (x << n) | (x >> (32 - n));

pragma(inline, true)
void chacha_quarter_round(uint a, uint b, uint c, uint d)(ref uint[16] state) pure
{
state[a] += state[b]; state[d] = rotl32!16(state[d] ^ state[a]);
state[c] += state[d]; state[b] = rotl32!12(state[b] ^ state[c]);
state[a] += state[b]; state[d] = rotl32!8(state[d] ^ state[a]);
state[c] += state[d]; state[b] = rotl32!7(state[b] ^ state[c]);
}

void chacha_block_next(ref ChaChaContext ctx) pure
{
// this is where the crazy voodoo magic happens.
// mix the bytes a lot and hope that nobody finds out how to undo it.
ctx.keystream32 = ctx.state;

// TODO: we might like to unroll this...?
foreach (i; 0 .. ctx.rounds)
{
chacha_quarter_round!(0, 4, 8, 12)(ctx.keystream32);
chacha_quarter_round!(1, 5, 9, 13)(ctx.keystream32);
chacha_quarter_round!(2, 6, 10, 14)(ctx.keystream32);
chacha_quarter_round!(3, 7, 11, 15)(ctx.keystream32);

chacha_quarter_round!(0, 5, 10, 15)(ctx.keystream32);
chacha_quarter_round!(1, 6, 11, 12)(ctx.keystream32);
chacha_quarter_round!(2, 7, 8, 13)(ctx.keystream32);
chacha_quarter_round!(3, 4, 9, 14)(ctx.keystream32);
}

ctx.keystream32[] += ctx.state[];

// increment counter
uint* counter = &ctx.state[12];
counter[0]++;
if (counter[0] == 0)
{
// wrap around occured, increment higher 32 bits of counter
counter[1]++;
// limited to 2^64 blocks of 64 bytes each.
// if you want to process more than 1180591620717411303424 bytes, you have other problems.
// we could keep counting with counter[2] and counter[3] (nonce), but then we risk reusing the nonce which is very bad!
assert(counter[1] != 0);
}
}


unittest
{
import urt.encoding;

immutable ubyte[32] test1_key = HexDecode!"0000000000000000000000000000000000000000000000000000000000000000";
immutable ubyte[12] test1_nonce = HexDecode!"000000000000000000000000";
immutable ubyte[64] test1_input = 0;
immutable ubyte[64] test1_output = [
0x76, 0xb8, 0xe0, 0xad, 0xa0, 0xf1, 0x3d, 0x90, 0x40, 0x5d, 0x6a, 0xe5, 0x53, 0x86, 0xbd, 0x28,
0xbd, 0xd2, 0x19, 0xb8, 0xa0, 0x8d, 0xed, 0x1a, 0xa8, 0x36, 0xef, 0xcc, 0x8b, 0x77, 0x0d, 0xc7,
0xda, 0x41, 0x59, 0x7c, 0x51, 0x57, 0x48, 0x8d, 0x77, 0x24, 0xe0, 0x3f, 0xb8, 0xd8, 0x4a, 0x37,
0x6a, 0x43, 0xb8, 0xf4, 0x15, 0x18, 0xa1, 0x1c, 0xc3, 0x87, 0xb6, 0x69, 0xb2, 0xee, 0x65, 0x86
];

immutable ubyte[32] test2_key = HexDecode!"0000000000000000000000000000000000000000000000000000000000000001";
immutable ubyte[12] test2_nonce = HexDecode!"000000000000000000000002";
immutable ubyte[375] test2_input = [
0x41, 0x6e, 0x79, 0x20, 0x73, 0x75, 0x62, 0x6d,0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x74,
0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x49, 0x45,0x54, 0x46, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x6e,
0x64, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74,0x68, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72,
0x69, 0x62, 0x75, 0x74, 0x6f, 0x72, 0x20, 0x66,0x6f, 0x72, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69,
0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61,0x73, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x6f, 0x72,
0x20, 0x70, 0x61, 0x72, 0x74, 0x20, 0x6f, 0x66,0x20, 0x61, 0x6e, 0x20, 0x49, 0x45, 0x54, 0x46,
0x20, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65,0x74, 0x2d, 0x44, 0x72, 0x61, 0x66, 0x74, 0x20,
0x6f, 0x72, 0x20, 0x52, 0x46, 0x43, 0x20, 0x61,0x6e, 0x64, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x73,
0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e, 0x74,0x20, 0x6d, 0x61, 0x64, 0x65, 0x20, 0x77, 0x69,
0x74, 0x68, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65,0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74,
0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x49,0x45, 0x54, 0x46, 0x20, 0x61, 0x63, 0x74, 0x69,
0x76, 0x69, 0x74, 0x79, 0x20, 0x69, 0x73, 0x20,0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x72,
0x65, 0x64, 0x20, 0x61, 0x6e, 0x20, 0x22, 0x49,0x45, 0x54, 0x46, 0x20, 0x43, 0x6f, 0x6e, 0x74,
0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e,0x22, 0x2e, 0x20, 0x53, 0x75, 0x63, 0x68, 0x20,
0x73, 0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e,0x74, 0x73, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75,
0x64, 0x65, 0x20, 0x6f, 0x72, 0x61, 0x6c, 0x20,0x73, 0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e,
0x74, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x49, 0x45,0x54, 0x46, 0x20, 0x73, 0x65, 0x73, 0x73, 0x69,
0x6f, 0x6e, 0x73, 0x2c, 0x20, 0x61, 0x73, 0x20,0x77, 0x65, 0x6c, 0x6c, 0x20, 0x61, 0x73, 0x20,
0x77, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x20,0x61, 0x6e, 0x64, 0x20, 0x65, 0x6c, 0x65, 0x63,
0x74, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x20, 0x63,0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x63, 0x61,
0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6d, 0x61,0x64, 0x65, 0x20, 0x61, 0x74, 0x20, 0x61, 0x6e,
0x79, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x6f,0x72, 0x20, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x2c,
0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x61,0x72, 0x65, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65,
0x73, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f
];
immutable ubyte[375] test2_output = [
0xa3, 0xfb, 0xf0, 0x7d, 0xf3, 0xfa, 0x2f, 0xde,0x4f, 0x37, 0x6c, 0xa2, 0x3e, 0x82, 0x73, 0x70,
0x41, 0x60, 0x5d, 0x9f, 0x4f, 0x4f, 0x57, 0xbd,0x8c, 0xff, 0x2c, 0x1d, 0x4b, 0x79, 0x55, 0xec,
0x2a, 0x97, 0x94, 0x8b, 0xd3, 0x72, 0x29, 0x15,0xc8, 0xf3, 0xd3, 0x37, 0xf7, 0xd3, 0x70, 0x05,
0x0e, 0x9e, 0x96, 0xd6, 0x47, 0xb7, 0xc3, 0x9f,0x56, 0xe0, 0x31, 0xca, 0x5e, 0xb6, 0x25, 0x0d,
0x40, 0x42, 0xe0, 0x27, 0x85, 0xec, 0xec, 0xfa,0x4b, 0x4b, 0xb5, 0xe8, 0xea, 0xd0, 0x44, 0x0e,
0x20, 0xb6, 0xe8, 0xdb, 0x09, 0xd8, 0x81, 0xa7,0xc6, 0x13, 0x2f, 0x42, 0x0e, 0x52, 0x79, 0x50,
0x42, 0xbd, 0xfa, 0x77, 0x73, 0xd8, 0xa9, 0x05,0x14, 0x47, 0xb3, 0x29, 0x1c, 0xe1, 0x41, 0x1c,
0x68, 0x04, 0x65, 0x55, 0x2a, 0xa6, 0xc4, 0x05,0xb7, 0x76, 0x4d, 0x5e, 0x87, 0xbe, 0xa8, 0x5a,
0xd0, 0x0f, 0x84, 0x49, 0xed, 0x8f, 0x72, 0xd0,0xd6, 0x62, 0xab, 0x05, 0x26, 0x91, 0xca, 0x66,
0x42, 0x4b, 0xc8, 0x6d, 0x2d, 0xf8, 0x0e, 0xa4,0x1f, 0x43, 0xab, 0xf9, 0x37, 0xd3, 0x25, 0x9d,
0xc4, 0xb2, 0xd0, 0xdf, 0xb4, 0x8a, 0x6c, 0x91,0x39, 0xdd, 0xd7, 0xf7, 0x69, 0x66, 0xe9, 0x28,
0xe6, 0x35, 0x55, 0x3b, 0xa7, 0x6c, 0x5c, 0x87,0x9d, 0x7b, 0x35, 0xd4, 0x9e, 0xb2, 0xe6, 0x2b,
0x08, 0x71, 0xcd, 0xac, 0x63, 0x89, 0x39, 0xe2,0x5e, 0x8a, 0x1e, 0x0e, 0xf9, 0xd5, 0x28, 0x0f,
0xa8, 0xca, 0x32, 0x8b, 0x35, 0x1c, 0x3c, 0x76,0x59, 0x89, 0xcb, 0xcf, 0x3d, 0xaa, 0x8b, 0x6c,
0xcc, 0x3a, 0xaf, 0x9f, 0x39, 0x79, 0xc9, 0x2b,0x37, 0x20, 0xfc, 0x88, 0xdc, 0x95, 0xed, 0x84,
0xa1, 0xbe, 0x05, 0x9c, 0x64, 0x99, 0xb9, 0xfd,0xa2, 0x36, 0xe7, 0xe8, 0x18, 0xb0, 0x4b, 0x0b,
0xc3, 0x9c, 0x1e, 0x87, 0x6b, 0x19, 0x3b, 0xfe,0x55, 0x69, 0x75, 0x3f, 0x88, 0x12, 0x8c, 0xc0,
0x8a, 0xaa, 0x9b, 0x63, 0xd1, 0xa1, 0x6f, 0x80,0xef, 0x25, 0x54, 0xd7, 0x18, 0x9c, 0x41, 0x1f,
0x58, 0x69, 0xca, 0x52, 0xc5, 0xb8, 0x3f, 0xa3,0x6f, 0xf2, 0x16, 0xb9, 0xc1, 0xd3, 0x00, 0x62,
0xbe, 0xbc, 0xfd, 0x2d, 0xc5, 0xbc, 0xe0, 0x91,0x19, 0x34, 0xfd, 0xa7, 0x9a, 0x86, 0xf6, 0xe6,
0x98, 0xce, 0xd7, 0x59, 0xc3, 0xff, 0x9b, 0x64,0x77, 0x33, 0x8f, 0x3d, 0xa4, 0xf9, 0xcd, 0x85,
0x14, 0xea, 0x99, 0x82, 0xcc, 0xaf, 0xb3, 0x41,0xb2, 0x38, 0x4d, 0xd9, 0x02, 0xf3, 0xd1, 0xab,
0x7a, 0xc6, 0x1d, 0xd2, 0x9c, 0x6f, 0x21, 0xba,0x5b, 0x86, 0x2f, 0x37, 0x30, 0xe3, 0x7c, 0xfd,
0xc4, 0xfd, 0x80, 0x6c, 0x22, 0xf2, 0x21
];

immutable ubyte[32] test3_key = HexDecode!"c46ec1b18ce8a878725a37e780dfb7351f68ed2e194c79fbc6aebee1a667975d";
enum ulong test3_nonce = 0x218268cfd531da1a;
immutable ubyte[127] test3_input = 0;
immutable ubyte[127] test3_output = [
0xf6, 0x3a, 0x89, 0xb7, 0x5c, 0x22, 0x71, 0xf9,0x36, 0x88, 0x16, 0x54, 0x2b, 0xa5, 0x2f, 0x06,
0xed, 0x49, 0x24, 0x17, 0x92, 0x30, 0x2b, 0x00,0xb5, 0xe8, 0xf8, 0x0a, 0xe9, 0xa4, 0x73, 0xaf,
0xc2, 0x5b, 0x21, 0x8f, 0x51, 0x9a, 0xf0, 0xfd,0xd4, 0x06, 0x36, 0x2e, 0x8d, 0x69, 0xde, 0x7f,
0x54, 0xc6, 0x04, 0xa6, 0xe0, 0x0f, 0x35, 0x3f,0x11, 0x0f, 0x77, 0x1b, 0xdc, 0xa8, 0xab, 0x92,
0xe5, 0xfb, 0xc3, 0x4e, 0x60, 0xa1, 0xd9, 0xa9,0xdb, 0x17, 0x34, 0x5b, 0x0a, 0x40, 0x27, 0x36,
0x85, 0x3b, 0xf9, 0x10, 0xb0, 0x60, 0xbd, 0xf1,0xf8, 0x97, 0xb6, 0x29, 0x0f, 0x01, 0xd1, 0x38,
0xae, 0x2c, 0x4c, 0x90, 0x22, 0x5b, 0xa9, 0xea,0x14, 0xd5, 0x18, 0xf5, 0x59, 0x29, 0xde, 0xa0,
0x98, 0xca, 0x7a, 0x6c, 0xcf, 0xe6, 0x12, 0x27,0x05, 0x3c, 0x84, 0xe4, 0x9a, 0x4a, 0x33
];

ubyte[375] output = void;

size_t ret = test1_input.chacha_crypt(output, test1_key, test1_nonce);
assert(ret == test1_input.length);
assert(output[0 .. test1_output.length] == test1_output[]);

ChaChaContext ctx;
ctx.chacha_init_context(test2_key, test2_nonce, 1);
ret = ctx.chacha_update(test2_input[0 .. 17], output[0 .. 17]);
ret += ctx.chacha_update(test2_input[17 .. $], output[17 .. $]);
assert(ret == test2_input.length);
assert(output[0 .. test2_output.length] == test2_output[]);

ret = test3_input.chacha_crypt(output, test3_key, test3_nonce);
assert(ret == test3_input.length);
assert(output[0 .. test3_output.length] == test3_output[]);
}
4 changes: 2 additions & 2 deletions src/urt/digest/md5.d
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -93,12 +93,12 @@ unittest
MD5Context ctx;
md5Init(ctx);
auto digest = md5Finalise(ctx);
assert(digest == Hex!"d41d8cd98f00b204e9800998ecf8427e");
assert(digest == HexDecode!"d41d8cd98f00b204e9800998ecf8427e");

md5Init(ctx);
md5Update(ctx, "Hello, World!");
digest = md5Finalise(ctx);
assert(digest == Hex!"65a8e27d8879283831b664bd8b7f0ad4");
assert(digest == HexDecode!"65a8e27d8879283831b664bd8b7f0ad4");
}


Expand Down
8 changes: 4 additions & 4 deletions src/urt/digest/sha.d
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -117,22 +117,22 @@ unittest
SHA1Context ctx;
shaInit(ctx);
auto digest = shaFinalise(ctx);
assert(digest == Hex!"da39a3ee5e6b4b0d3255bfef95601890afd80709");
assert(digest == HexDecode!"da39a3ee5e6b4b0d3255bfef95601890afd80709");

shaInit(ctx);
shaUpdate(ctx, "Hello, World!");
digest = shaFinalise(ctx);
assert(digest == Hex!"0a0a9f2a6772942557ab5355d76af442f8f65e01");
assert(digest == HexDecode!"0a0a9f2a6772942557ab5355d76af442f8f65e01");

SHA256Context ctx2;
shaInit(ctx2);
auto digest2 = shaFinalise(ctx2);
assert(digest2 == Hex!"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
assert(digest2 == HexDecode!"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");

shaInit(ctx2);
shaUpdate(ctx2, "Hello, World!");
digest2 = shaFinalise(ctx2);
assert(digest2 == Hex!"dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f");
assert(digest2 == HexDecode!"dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f");
}


Expand Down
Loading
Loading