Yes, Carry-free addition is just the Xor operation (for 1 bit numbers only!). However, if you just want the cryptography, may I recommend SHA-1? If you want to learn, then I'd recommend trying a simpler, more widely used hash function like MD5.

PS: SHA-2 defines more than one function

I don't do easy.
SHA-2 is probably gonna be the standard by the time I graduate from college.
http://ourl.ca/10538
So. What are these other functions?

I know. But the competition to create SHA-3 hasn't even happened yet, and companies are probably gonna stick with SHA-2 except for their most highly sensitive stuffs.

Axe.

I know. But the competition to create SHA-3 hasn't even happened yet, and companies are probably gonna stick with SHA-2 except for their most highly sensitive stuffs.

Um, the competition started almost three years ago. Also, companies will start replacing their SHA-2 algorithms within a few years, hence the "4 years" thing I mentioned in my previous post. But, I'll assume you have some legitimate use for SHA-2, since I likewise expect people to understand my use of Hex rather than ASM or C.

Okay, first off, there are a few kinds of SHA-2 algorithms. The most common are probably SHA-224 and SHA-256, since these are the versions endorsed by NIST. I'll focus on the SHA-224 algorithm for no particular reason. The two algorithms are precisely identical except for the initial state of the function and the ending truncation of the hash.

Before we start, I'm going to tell you that you will have to write routines for *every* arithmetic operation you do in with a SHA-algorithm. They are really much more suited to Assembly than Axe, as they only work when the word size is 32 bits, something that Axe doesn't natively permit. Also, addition is always taken modulo 2³². Then, you also have to work out how you're going to do right shifts (SHR), which are something very easily done inASM. This is actually very simple. All you have to do is divide the number by two for each single shift right. However, for the upper 16 bits of each number, you will have to check each bit position to see if you should set the corresponding bit position in the lower 16 bits. Once you have an arithmetic shift, you also need the rotate right and left operations, which are synthesized for n bit rotations as follows:

ROTR: (x >> n) v (x << 32 - n)
ROTL: (x << n) ^ (x >> 32 - n)

Note that ROTR^N=ROTL^32-N

Also, SHA-256 employs six functions to compute the hash:

Ch( x, y, z) = ( x ^ y) XOR (NOT(x) ^ z)
Maj( x, y, z) = ( x ^ y) XOR ( x ^ z) XOR( y ^ z)
∑₀ = ROTR² XOR ROTR¹³ XOR ROTR²²
∑₁ = ROTR⁶ XOR ROTR¹¹ XOR ROTR²⁵
σ₀ = ROTR⁷ XOR ROTR¹⁸ XOR SHR³
σ₀ = ROTR¹⁷ XOR ROTR¹⁹ XOR SHR¹⁰

To begin with, the SHA-224 standard defines eight constants for the initial state. These are

H₀ = c1059ed8
H₁ = 367cd507
H₂ = 3070dd17
H₃ = f70e5939
H₄ = ffc00b31
H₅ = 68581511
H₆ = 64f98fa7
H₇ = befa4fa4

Er, sorry, I apparently really need to be somewhere else right now. I'll try to finish when I get back. This should be enough material to understand the scope of the project and begin implementing it.

Willrandship: The reason is probably that it's now within reason to brute force SHA-2 hashes, whereas it wasn't back when it was implemented. Also, the SHA-3 standard will in all likelihood have nothing to do with the SHA-1 and SHA-2 hashes.

I got 32 bit addition figured out. Here's the carry:
.A: up 16 int 1
.B: low 16 int 1
.C: up 16 int 2
.D: low 16 int 2

If -B<=D
A+1->A
End


Yeah. This is my bit rotation right.
A/2->C
B/2->D
If A^2
D+ e^(15)->D
End
If B^2
C+e^(15)->C
End
C->A
D->B