The ISAAC cipher: Difference between revisions

ISAAC is a cryptographically secure pseudo-random number generator (CSPRNG) and stream cipher. It was developed by Bob Jenkins from 1993 (http://burtleburtle.net/bob/rand/isaac.html) and placed in the Public Domain. ISAAC is fast - especially when optimised - and portable to most architectures in nearly all programming and scripting languages.

It is also simple and succinct, using as it does just two 256-word arrays for its state.

But building a strong and simple ISAAC-based stream cipher - replacing the irreparably broken RC4 - is our goal here: ISAAC's intended purpose.

<br><br>

 

=={{header|C}}==

At the top is Bob Jenkins' reference code for ISAAC.

Below and in main() is the task's complete solution for XOR and MOD.

/* Known to compile and work with tcc in win32 & gcc on Linux (with warnings)

------------------------------------------------------------------------------

return 0;

}

{{out}}

<pre>

=={{header|C sharp}}==

XOR with decryption check.

using System;

 

}

}

{{out}}

<pre>

XOR : 1C0636190B1260233B35125F1E1D0E2F4C5422

XOR dcr: a Top Secret secret

</pre>

 

=={{header|Common Lisp}}==

(:use cl))

 

(terpri)

(format t "MOD dcr: ~a~%" cptx))))

{{out}}

<pre>ISAAC> (main-test)

=={{header|D}}==

Improved from the C# version. XOR with decryption check.

import std.algorithm: copy;

import std.typetuple: TypeTuple;

 

writeln("Decrypted: ", decrypted.assumeUTF);

{{out}}

<pre>Message : a Top Secret secret

=={{header|Delphi}}==

Translation of Pascal.

{$apptype console}

PROGRAM RosettaIsaac;

Writeln('MOD : ',mctx);

END.

{{out}}

<pre>

{{works with|node.js|0.10.32}}

{{trans|C#}}

randcnt = 0;

mm = new Uint32Array(256);

xptx = z[1];

console.log('xor: '+printable_hex(xctx))

{{out}}

<pre>

decrypted: a Top Secret secret

</pre>

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

{{out}}

 

=={{header|Go}}==

XOR version

 

import "fmt"

}

return fmt.Sprintf("%X", b)

{{out}}

<pre>

 

=={{header|Haskell}}==

 

type IArray = Array Word32 Word32

{ randrsl :: IArray

, randcnt :: Word32

}

 

instance Show IsaacState where

 

toHex :: Char -> String

mix set = foldl aux set [11, -2, 8, -16, 10, -4, 8, -9]

where

 

-- Generate the next 256 words.

isaac :: IsaacState -> IsaacState

where

 

-- Given a seed value in randrsl, initialize/mixup the state.

randinit :: IsaacState -> Bool -> IsaacState

where

iter flag set rsl =

let (rslH, rslT) = splitAt 8 rsl

 

-- Given a string seed, optionaly use it to generate a new state.

seed :: String -> Bool -> IsaacState

seed key flag =

state = IState rsl 0 m 0 0 0

in randinit state flag

random :: IsaacState -> (Word32, IsaacState)

random state@(IState rsl cnt m a b c) =

 

-- Produce a stream of random words from the given state.

randA :: IsaacState -> (Char, IsaacState)

randA state =

 

-- Produce a stream of printable characters from the given state.

-- Vernam encode/decode a string with the given state.

vernam :: IsaacState -> String -> String

where

 

main :: IO ()

main = do

unver = vernam st ver

putStrLn $ "Message: " ++ msg

putStrLn $ "Key : " ++ key

putStrLn $ "XOR : " ++ hexify ver

{{out}}

<pre>Message: a Top Secret secret

It is possible in Haxe to create your own 32bit unsigned type,

but that is outside this exercise.

package src ;

import haxe.Int32;

}

}

{{out}}

<pre>

MOD dcr: a Top Secret secret

</pre>

 

=={{header|Java}}==

This implementation extends the java.util.Random class, so it inherits methods that generate booleans, floats, doubles and longs, and can also generate numbers with Gaussian and uniform distribution. It can also be plugged in to standard library methods that receive a Random instance as a source of randomness. The toHexString() and main() methods are for demo purposes only and can be removed without changing main functionality.

 

import java.util.Arrays;

import java.util.Random;

System.out.printf("MOD dcr: %s\n", caesarDecrypted);

}

 

=={{header|Kotlin}}==

{{trans|C}}

 

/* external results */

println("MOD : ${cctx.toHexByteString()}")

println("MOD dcr : $cptx")

 

{{out}}

</pre>

 

 

 

 

PROCEDURE Isaac;

BEGIN

END;

 

 

BEGIN

 

 

BEGIN

 

END;

 

 

 

BEGIN

 

 

BEGIN

 

 

 

 

 

 

 

 

 

 

 

 

BEGIN

 

{{out}}

<pre>

as well as additional convenience functions.

 

use strict;

use Math::Random::ISAAC;

map { ord($_) ^ shift(@iranda) } # xor it with rand char

split "", $msg; # Take each character

{{out}}

<pre>

XOR : 1C0636190B1260233B35125F1E1D0E2F4C5422

XOR dcr: a Top Secret secret

</pre>

 

=={{header|PicoLisp}}==

(mod32 (pass +)) )

 

95 ) ) ) ) ) ) ) ) ) )

 

 

=={{header|Python}}==

This implementation extends the Random class of the built-in random module, so it automatically inherits methods for generating several distributions, as well as support for shuffling and sampling collections.

 

import collections

 

print('MOD :', hexify(caesar_encoded))

print('MOD dcr:', caesar_decoded)

 

=={{header|Racket}}==

left from after the XOR, and one with a cleanly reseeded state engine.

 

;; Imperative version: Translation of C

;; Vigenère: Translation of Pascal

(randctx-b C) => #x902c0691

(randctx-c C) => 10))

 

{{out}}

< context reseeded

Vigenère (-MOD): [6120546f702053656372657420736563726574 "a Top Secret secret"]</pre>

 

=={{header|REXX}}==

===version 1===

* 24.07.2014 Walter Pachl translated from Pascal

* extend with decryption (following Pascal)

If arg(3)<>'' Then

res=res+arg(3)

{{out}}

<pre>Message: a Top Secret secret

 

===version 2===

* 25.07.2014 Walter Pachl framing version 1 for processing a file

*--------------------------------------------------------------------*/

parse Arg fid

Parse Var fid fn '.' ft

{{out}}

<pre>Please enter a key

This is a little test file

that shows my encryption</pre>

 

=={{header|Sidef}}==

{{trans|Perl}}

 

func xor_isaac(key, msg) {

say "Key : #{key}"

say "XOR : #{enc}"

{{out}}

<pre>

{{works with|Tcl|8.6}}

{{trans|Go}}

 

oo::class create ISAAC {

return [binary encode hex [binary format c* $b]]

}

Demonstrating:

set msg "a Top Secret secret"

ISAAC create demo $key

puts "Message: $msg"

puts "Key : $key"

{{out}}

<pre>

Key : this is my secret key

XOR : 1c0636190b1260233b35125f1e1d0e2f4c5422

</pre>