The ISAAC cipher: Difference between revisions

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>

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

{{trans|Modula-2}}

#include <iomanip>

#include <iostream>

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

}

{{out}}

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

</pre>

=={{header|Forth}}==

Tested for VFX Forth and GForth 64bit in Linux

The code was based on and debugged v python

caesar>in decode caesar

CR ." Caesar decoded : " caesar-out buff. ;

{{out}}

<pre>

=={{header|FreeBASIC}}==

{{trans|C}}

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>message: a Top Secret secret

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

{{trans|C}}

In this draft, only the XOR implementation (vernam) is implemented:

ub4=: (#.33{.1)&|

xor=: ub4@(2b10110 b.)

}}

 

 

1c0636190b1260233b35125f1e1d0e2f4c5422

vernam E [ 1 iSeed 'this is my secret key'

 

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

 

=={{header|Lua}}==

-- ISAAC - Lua 5.3

 

 

main()

{{out}}

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

 

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

END RosettaIsaac.

{{out}}

<pre>

Note that the "mix" procedure could possibly be transformed in a template or be marked as "inline" (in the C version, it is a "define"). But as we are not in procedure whose performance is critical, expanding the code rather than calling a procedure is not very useful.

 

 

type

echo " MOD: ", mctx.toHex

echo "XOR dcr: ", xptx

 

{{out}}

=={{header|Pascal}}==

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

PROGRAM RosettaIsaac;

USES

Writeln('MOD dcr: ', mptx);

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>

{{trans|Pascal}}

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

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\ISAAC_Cipher.exw

<span style="color: #0000FF;">?</span><span style="color: #008000;">"done"</span>

<span style="color: #0000FF;">{}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">wait_key</span><span style="color: #0000FF;">()</span>

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

=={{header|Raku}}==

(formerly Perl 6)

my \ϕ := 2654435769; constant MOD = 95; constant START = 32;

 

say "MOD : ", $cctx2hex;

say "MOD dcr : ", $cptx;

{{out}}

<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

 

=={{header|Rust}}==

//! includes the XOR version of the encryption scheme

 

}

 

{{out}}

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

{{libheader|Wren-dynamic}}

{{libheader|Wren-fmt}}

import "/dynamic" for Enum

import "/fmt" for Fmt

System.print("XOR dcr : %(vptx)")

System.print("MOD : %(toHexByteString.call(cctx))")

 

{{out}}