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>

MOD : 734270227D36772A783B4F2A5F206266236978

MOD dcr: a Top Secret secret

</pre>

 

=={{header|C++}}==

{{trans|Modula-2}}

#include <iomanip>

#include <iostream>

cout << "MOD dcr: " << modPlainText << endl;

}

{{out}}

<pre>

XOR dcr: a Top Secret secret

MOD 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}}==

import Data.Word (Word, Word32)

import Data.Bits (shift, xor)

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|Julia}}==

"""

Julia translation of code from the following:

const key = "this is my secret key"

test(IState(), msg, key)

{{output}}<pre>

Message: a Top Secret secret

=={{header|Kotlin}}==

{{trans|C}}

 

/* external results */

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

println("MOD dcr : $cptx")

 

{{out}}

MOD : 734270227D36772A783B4F2A5F206266236978

MOD dcr : a Top Secret secret

</pre>

 

{{works with|ADW Modula-2|any (Compile with the linker option ''Console Application'').}}

I changed the identifiers to clearer ones and I changed the variables <code>a</code>, <code>b</code>, ..., <code>h</code> to an array, because they made my blood boil.

MODULE RosettaIsaac;

 

TMode = (iEncrypt, iDecrypt);

TString = ARRAY [0 .. MaxStrLength - 1] OF CHAR;

TCardIndexedFrom0To7 = ARRAY [0 .. 7] OF CARDINAL;

 

XorPlainText: TString = '';

ModPlainText: TString = '';

 

(* ISAAC globals *)

(* external results *)

RandCnt: CARDINAL;

 

(* internal state *)

AA: CARDINAL = 0;

BB: CARDINAL = 0;

PROCEDURE SeedIsaac(Seed: ARRAY OF CHAR; Flag: BOOLEAN);

VAR

BEGIN

FOR I := 0 TO 255 DO

MM[I] := 0;

END;

FOR I := 0 TO 255 DO

(* In case seed has less than 256 elements *)

RandRsl[I] := 0

ELSE

OrdMsgI: SHORTCARD;

BEGIN

FOR I := 0 TO Length(Msg) - 1 DO

OrdMsgI := ORD(Msg[I]);

END;

END Vernam;

I: CARDINAL;

BEGIN

FOR I := 0 TO Length(Msg) - 1 DO

END;

END Vigenere;

SeedIsaac(Key, TRUE);

(* (2) Encryption *)

(* (a) XOR (Vernam) *)

Vernam(Msg, XorCipherText);

(* (b) MOD (Vigenere) *)

(* (3) Decryption *)

SeedIsaac(Key, TRUE);

(* (a) XOR (Vernam) *)

Vernam(XorCipherText, XorPlainText);

(* (b) MOD (Vigenere) *)

(* program output *)

WriteString('Message: '); WriteString(Msg); WriteLn;

WriteString('MOD dcr: '); WriteString(ModPlainText); WriteLn;

END RosettaIsaac.

{{out}}

<pre>

MOD dcr: a Top Secret secret

</pre>

 

=={{header|Pascal}}==

Free Pascal. A fully functional and complete reference solution of the task.

PROGRAM RosettaIsaac;

 

// TASK globals

 

// ISAAC globals

 

 

PROCEDURE Isaac;

BEGIN

 

 

BEGIN

 

BEGIN

 

 

END;

 

 

 

BEGIN

 

BEGIN

 

BEGIN

END;

 

 

 

 

 

 

BEGIN

END.

{{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>

 

{{trans|Pascal}}

We need the r32() function to convert our common sense maths into the needed unsigned_and_throw_away_any_high_bits maths.

{{out}}

<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===

This can be used to encrypt a file and thereafter decrypt it.

* 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>