frereth.cp.shared.bit-twiddling — com.frereth/cp 0.0.5

Shared functions for fiddling with bits

->string clj

(->string x)

byte-copy! clj

(byte-copy! dst src)

(byte-copy! dst offset n src)

(byte-copy! dst offset n src src-offset)

Copies the bytes from src to dst

bytes= clj

(bytes= x y)

extract-rightmost-byte clj

(extract-rightmost-byte n)

Since bytes are signed in java

possibly-2s-complement-8 clj

(possibly-2s-complement-8 n)

If an unsigned byte is greater than 127, it needs to be negated to fit into a signed byte.

Thanks, java, for having a crippled numeric stack.

possibly-2s-uncomplement-16 clj

(possibly-2s-uncomplement-16 n)

Note that this is specifically for a pair of bytes

possibly-2s-uncomplement-32 clj

(possibly-2s-uncomplement-32 n)

Note that this is specifically for a quad-byte

possibly-2s-uncomplement-64 clj

(possibly-2s-uncomplement-64 n)

Note that this is specifically for an 8 byte sequence

possibly-2s-uncomplement-8 clj

(possibly-2s-uncomplement-8 n)

Note that this is specifically for a single byte

possibly-2s-uncomplement-n clj

(possibly-2s-uncomplement-n n maximum)

Convert [signed] complemented n into unsigned that fits maximum

secure-mod clj

(secure-mod numerator denominator)

DJB sort-of uses this approach in randommod.

Do not use.

It's significantly slower than ordinary mod

I'm pretty sure its only purpoe in life is that C doesn't support really big numbers.

On lots of platforms, a long long is only 64 bits.

Since we're looking at 256 bits right off the bat, java wins here.

sub-byte-array clj

(sub-byte-array src beg)

(sub-byte-array src beg end)

Return an array that copies a portion of the source

uint-pack! clj

(uint-pack! dst index src size)

uint16-pack clj

(uint16-pack x)

uint16-pack! clj

(uint16-pack! dst index src)

Sets 2 bytes in dst (starting at offset n) to x

uint16-unpack clj

(uint16-unpack src)

(uint16-unpack src offset)

Unpack an array of 2 bytes into a 16-bit short

uint32-pack! clj

(uint32-pack! dst index src)

Sets 4 bytes in dst (starting at offset n) to x

uint32-unpack clj

(uint32-unpack src)

Unpack an array of 32 bytes into a 32-bit long

uint64-pack clj

(uint64-pack x)

uint64-pack! clj

(uint64-pack! dst index src)

Sets 8 bytes in dst (starting at offset n) to x

Note that this looks/smells very similar to TweetNaclFast's Box.generateNonce.

But I don't see an obvious way to reverse that, and it's buried inside a class.

So stick with this translation.

uint64-unpack clj

(uint64-unpack src)

Unpack an array of 8 bytes into a 64-bit long

zero-out! clj

(zero-out! dst start end)

Shove zeros into the byte-array at dst, from offset start to offset end