Raaz.Core.Primitives

Generic cryptographic block primtives and their implementations. This module exposes low-level generic code used in the raaz system. Most likely, one would not need to stoop so low and it might be better to use a more high level interface.

Primtives and their implementations.

class Describable (Implementation p) => Primitive p where

The type class that captures an abstract block cryptographic primitive. Bulk cryptographic primitives like hashes, ciphers etc often acts on blocks of data. The size of the block is captured by the member blockSize.

As a library, raaz believes in providing multiple implementations for a given primitive. The associated type Implementation captures implementations of the primitive.

There is a reference implementation where the emphasis is on correctness rather than speed or security. They are used to verify the correctness of the other implementations for the same primitive. Apart from this, for production use, we have a recommended implementation.

Minimal complete definition

blockSize

Associated Types

type Implementation p :: *

Associated type that captures an implementation of this primitive.

Methods

blockSize :: p -> BYTES Int

The block size.

Instances

Primitive SHA1

Associated Types

type Implementation SHA1 :: *

Methods

blockSize :: SHA1 -> BYTES Int

Primitive SHA224

Associated Types

type Implementation SHA224 :: *

Methods

blockSize :: SHA224 -> BYTES Int

Primitive SHA256

Associated Types

type Implementation SHA256 :: *

Methods

blockSize :: SHA256 -> BYTES Int

Primitive SHA384

Associated Types

type Implementation SHA384 :: *

Methods

blockSize :: SHA384 -> BYTES Int

Primitive SHA512

Associated Types

type Implementation SHA512 :: *

Methods

blockSize :: SHA512 -> BYTES Int

Hash h => Primitive (HMAC h)

Associated Types

type Implementation (HMAC h) :: *

Methods

blockSize :: HMAC h -> BYTES Int

Primitive (AES 128 CBC)

The 128-bit aes cipher in cbc mode.

Associated Types

type Implementation (AES 128 CBC) :: *

Methods

blockSize :: AES 128 CBC -> BYTES Int

Primitive (AES 192 CBC)

The 192-bit aes cipher in cbc mode.

Associated Types

type Implementation (AES 192 CBC) :: *

Methods

blockSize :: AES 192 CBC -> BYTES Int

Primitive (AES 256 CBC)

The 256-bit aes cipher in cbc mode.

Associated Types

type Implementation (AES 256 CBC) :: *

Methods

blockSize :: AES 256 CBC -> BYTES Int

class Primitive prim => Symmetric prim

A symmetric primitive. An example would be primitives like Ciphers, HMACs etc.

Associated Types

type Key prim

The key for the primitive.

Instances

Hash h => Symmetric (HMAC h)

Associated Types

type Key (HMAC h) :: *

Symmetric (AES 128 CBC)

Key is (KEY128,IV) pair.

Associated Types

type Key (AES 128 CBC) :: *

Symmetric (AES 192 CBC)

Key is (KEY192,IV) pair.

Associated Types

type Key (AES 192 CBC) :: *

Symmetric (AES 256 CBC)

Key is (KEY256,IV) pair.

Associated Types

type Key (AES 256 CBC) :: *

class Asymmetric prim

An asymmetric primitive.

Associated Types

type PublicKey prim

The public key

type PrivateKey prim

The private key

class Primitive p => Recommendation p where

Primitives that have a recommended implementations.

Minimal complete definition

recommended

Methods

recommended :: p -> Implementation p

The recommended implementation for the primitive.

Instances

(Hash h, Recommendation h) => Recommendation (HMAC h)

Methods

recommended :: HMAC h -> Implementation (HMAC h)

data BLOCKS p

Type safe message length in units of blocks of the primitive. When dealing with buffer lengths for a primitive, it is often better to use the type safe units BLOCKS. Functions in the raaz package that take lengths usually allow any type safe length as long as they can be converted to bytes. This can avoid a lot of tedious and error prone length calculations.

Instances

Enum (BLOCKS p)

Methods

succ :: BLOCKS p -> BLOCKS p

pred :: BLOCKS p -> BLOCKS p

toEnum :: Int -> BLOCKS p

fromEnum :: BLOCKS p -> Int

enumFrom :: BLOCKS p -> [BLOCKS p]

enumFromThen :: BLOCKS p -> BLOCKS p -> [BLOCKS p]

enumFromTo :: BLOCKS p -> BLOCKS p -> [BLOCKS p]

enumFromThenTo :: BLOCKS p -> BLOCKS p -> BLOCKS p -> [BLOCKS p]

Eq (BLOCKS p)

Methods

(==) :: BLOCKS p -> BLOCKS p -> Bool

(/=) :: BLOCKS p -> BLOCKS p -> Bool

Integral (BLOCKS p)

Methods

quot :: BLOCKS p -> BLOCKS p -> BLOCKS p

rem :: BLOCKS p -> BLOCKS p -> BLOCKS p

div :: BLOCKS p -> BLOCKS p -> BLOCKS p

mod :: BLOCKS p -> BLOCKS p -> BLOCKS p

quotRem :: BLOCKS p -> BLOCKS p -> (BLOCKS p, BLOCKS p)

divMod :: BLOCKS p -> BLOCKS p -> (BLOCKS p, BLOCKS p)

toInteger :: BLOCKS p -> Integer

Num (BLOCKS p)

Methods

(+) :: BLOCKS p -> BLOCKS p -> BLOCKS p

(-) :: BLOCKS p -> BLOCKS p -> BLOCKS p

(*) :: BLOCKS p -> BLOCKS p -> BLOCKS p

negate :: BLOCKS p -> BLOCKS p

abs :: BLOCKS p -> BLOCKS p

signum :: BLOCKS p -> BLOCKS p

fromInteger :: Integer -> BLOCKS p

Ord (BLOCKS p)

Methods

compare :: BLOCKS p -> BLOCKS p -> Ordering

(<) :: BLOCKS p -> BLOCKS p -> Bool

(<=) :: BLOCKS p -> BLOCKS p -> Bool

(>) :: BLOCKS p -> BLOCKS p -> Bool

(>=) :: BLOCKS p -> BLOCKS p -> Bool

max :: BLOCKS p -> BLOCKS p -> BLOCKS p

min :: BLOCKS p -> BLOCKS p -> BLOCKS p

Real (BLOCKS p)

Methods

toRational :: BLOCKS p -> Rational

Show (BLOCKS p)

Methods

showsPrec :: Int -> BLOCKS p -> ShowS

show :: BLOCKS p -> String

showList :: [BLOCKS p] -> ShowS

Primitive p => LengthUnit (BLOCKS p)

Methods

inBytes :: BLOCKS p -> BYTES Int

blocksOf :: Primitive p => Int -> p -> BLOCKS p

The expression n blocksOf p specifies the message lengths in units of the block length of the primitive p. This expression is sometimes required to make the type checker happy.