Main step of GOST 28147-89: Difference between revisions

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

table&() = 4, 10, 9, 2, 13, 8, 0, 14, 6, 11, 1, 12, 7, 15, 5, 3, \

\ 14, 11, 4, 12, 6, 13, 15, 10, 2, 3, 8, 1, 0, 7, 5, 9, \

WHILE v>&7FFFFFFF : v-=2^32 : ENDWHILE

WHILE v<&80000000 : v+=2^32 : ENDWHILE

'''Output:'''

<pre>

Version with packed replacement table.

 

static unsigned char const k7[16] = { 15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10 };

static unsigned char const k6[16] = { 10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8 };

k43[x>> 8 & 255] << 8 | k21[x & 255];

return x<<11 | x>>(32-11);

 

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

{

UINT_64 N;

N1 = S;

return SWAP32(N2,N1);

 

Variable "BS" is the replacement table.

{{trans|C}}

{{trans|Go}}

 

/// Rotate uint left.

g.mainStep(input, key);

writefln("%(%08X %)", g.buffer);

{{out}}

<pre>07CF881F 043B0421</pre>

 

=={{header|Glagol}}==

 

=={{header|Go}}==

 

import "fmt"

}

fmt.Println()

{{out}}

<pre>

[1f][88][cf][07][21][04][3b][04]

</pre>

 

=={{header|JavaScript}}==

const Таблица_замен = [

[ 4, 10, 9, 2, 13, 8, 0, 14, 6, 11, 1, 12, 7, 15, 5, 3],

for (let сч = 0; сч < 4; сч++) {

const яч = (S >>> (сч << 3)) & 0xFF;

}

N[1] = N[0]; N[0] = нов_S;

return N;

};

 

Note: the variable "блок_текста" is an array of two 32-bit values that make up the block.

=={{header|Julia}}==

{{trans|Kotlin}}

const k8 = [ 4, 10, 9, 2, 13, 8, 0, 14, 6, 11, 1, 12, 7, 15, 5, 3]

const k7 = [14, 11, 4, 12, 6, 13, 15, 10, 2, 3, 8, 1, 0, 7, 5, 9]

end

 

 

function mainstep(inputbytes, keybytes)

const key = [0xF9, 0x04, 0xC1, 0xE2]

println("The encoded bytes are $(mainstep(input, key))")

{{output}}<pre>

The encoded bytes are UInt8[0x1f, 0x88, 0xcf, 0x07, 0x21, 0x04, 0x3b, 0x04]</pre>

=={{header|Kotlin}}==

{{trans|Go}}

 

fun Byte.toUInt() = java.lang.Byte.toUnsignedInt(this)

for (b in g.enc) print("[%02X]".format(b))

println()

 

{{out}}

 

Code for the first module:

x>=0 14 П7 КИП6 ИП6 ИПE - x>=0 20 П6

8 П2 П3 2 П1 4 П0 0 П8 1

П5 ИП4 ИП6 П4 <-> П6 ИП5 ИП7 П5 <->

П7 БП 00 ИПC / [x] КП0 Вx {x} ИПC

 

Code for the second module:

2 / [x] П1 Вx {x} ИП2 2 / [x]

П2 Вx {x} <-> -> - x#0 33 ИП4 ИП3

+ П3 ИП4 ^ + П4 L0 10 ИП3 С/П

 

<u>Instruction</u>:

Algorithm inspired from C, Go, etc.

The Sboxes are computed at compile time.

 

const

 

let output = mainStep(Input, Key)

 

{{out}}

{{trans|Raku}}

{{libheader|ntheory}}

use warnings;

use ntheory 'fromdigits';

 

printf '%02X ', (($L << 32) + $R >> (8*$_))%256 for 0..7;

{{out}}

<pre>1F 88 CF 07 21 04 3B 04</pre>

=={{header|Phix}}==

{{trans|D}}

{{out}}

<pre>

=={{header|PicoLisp}}==

{{trans|C}}

(setq K2 ( 4 11 2 14 15 0 8 13 3 12 9 7 5 10 6 1))

(setq K3 (12 1 10 15 9 2 6 8 0 13 3 4 14 7 5 11))

11 ) )

 

=={{header|Python}}==

{{trans|C}}

k8 = [ 14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7 ]

k7 = [ 15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10 ]

x = ( k87[x>>24 & 255] << 24 | k65[x>>16 & 255] << 16 |

k43[x>> 8 & 255] << 8 | k21[x & 255] )

 

=={{header|Racket}}==

This is a direct translation of the C code, but I have no idea if that code is correct, or a way to test it. (I suspect that it isn't, at least since the table has different numbers than the wikipedia article...)

#lang racket

 

(bitwise-ior (bitwise-and #xFFFFFFFF (arithmetic-shift x* 11))

(arithmetic-shift x* (- 11 32))))

 

=={{header|Raku}}==

Implemented to match explanation on Discussion page:

 

constant sbox =

[4, 10, 9, 2, 13, 8, 0, 14, 6, 11, 1, 12, 7, 15, 5, 3],

($L,$R) = feistel-step(&ГОСТ-round, $L, $R, $K);

 

 

{{out}}

=={{header|REXX}}==

{{trans|BBC BASIC}}

numeric digits 12 /* ┌── a list of 4─bit S─box values used by */

/* ↓ the Central Bank of Russian Federation.*/

/* [↓] encryption algorithm round. */

k = c2d( bitxor( bitor( d2c(z * 2**11, 4), d2c(z % 2**21, 4) ), d2c(#2, 4) ) )

{{out|output|:}}

<pre>

7CF881F 43B0421

</pre>

 

=={{header|Rust}}==

use std::env;

use std::num::Wrapping;

n[3] = (s & 0xFF).try_into().unwrap();

n

{{out}}

<pre>

 

=={{header|Tcl}}==

proc tcl::mathfunc::k {a b} {

variable ::GOST::replacementTable

return $textBlock

}

Note that only the <tt>idx</tt>'th row of the split-up <tt>textBlock</tt> (which contains the two pieces to intermingle/exchange at this step) is altered; it is the responsibility of the caller to iterate over all the steps through the entire plaintext/ciphertext.

 

* The contents of the segment registers unchanged.

 

.model flat

.code

ret

_gost32 endp

 

=={{header|Wren}}==

{{libheader|Wren-fmt}}

{{trans|Go}}

 

class GOST {

var g = GOST.new(cbrf)

g.mainStep(input, key)

 

{{out}}

{{trans|D}}

This could very well fail on a non-Intel endian-ness.

var [const] // Central Bank of Russian Federation S-Boxes

k8=Data(0,Int, 4, 10, 9, 2, 13, 8, 0, 14, 6, 11, 1, 12, 7, 15, 5, 3),

}

r

input:=Data(0,Int,0x21, 0x04, 0x3B, 0x04, 0x30, 0x04, 0x32, 0x04);

key := 0xE2|C1|04|F9; // big endian

 

{{out}}

<pre>[1f][88][cf][07][21][04][3b][04]</pre>