src/cypherpunks.ru/gogost/gost3412128/cipher.go

   1 // GoGOST -- Pure Go GOST cryptographic functions library
   2 // Copyright (C) 2015-2019 Sergey Matveev <stargrave@stargrave.org>
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation, either version 3 of the License, or
   7 // (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 // GOST 34.12-2015 128-bit (Кузнечик (Kuznechik)) block cipher.
  18 package gost3412128
  19
  20 const (
  21         BlockSize = 16
  22         KeySize   = 32
  23 )
  24
  25 var (
  26         lc [BlockSize]byte = [BlockSize]byte{
  27                 148, 32, 133, 16, 194, 192, 1, 251, 1, 192, 194, 16,
  28                 133, 32, 148, 1,
  29         }
  30         pi [256]byte = [256]byte{
  31                 252, 238, 221, 17, 207, 110, 49, 22, 251, 196, 250,
  32                 218, 35, 197, 4, 77, 233, 119, 240, 219, 147, 46,
  33                 153, 186, 23, 54, 241, 187, 20, 205, 95, 193, 249,
  34                 24, 101, 90, 226, 92, 239, 33, 129, 28, 60, 66, 139,
  35                 1, 142, 79, 5, 132, 2, 174, 227, 106, 143, 160, 6,
  36                 11, 237, 152, 127, 212, 211, 31, 235, 52, 44, 81,
  37                 234, 200, 72, 171, 242, 42, 104, 162, 253, 58, 206,
  38                 204, 181, 112, 14, 86, 8, 12, 118, 18, 191, 114, 19,
  39                 71, 156, 183, 93, 135, 21, 161, 150, 41, 16, 123,
  40                 154, 199, 243, 145, 120, 111, 157, 158, 178, 177,
  41                 50, 117, 25, 61, 255, 53, 138, 126, 109, 84, 198,
  42                 128, 195, 189, 13, 87, 223, 245, 36, 169, 62, 168,
  43                 67, 201, 215, 121, 214, 246, 124, 34, 185, 3, 224,
  44                 15, 236, 222, 122, 148, 176, 188, 220, 232, 40, 80,
  45                 78, 51, 10, 74, 167, 151, 96, 115, 30, 0, 98, 68,
  46                 26, 184, 56, 130, 100, 159, 38, 65, 173, 69, 70,
  47                 146, 39, 94, 85, 47, 140, 163, 165, 125, 105, 213,
  48                 149, 59, 7, 88, 179, 64, 134, 172, 29, 247, 48, 55,
  49                 107, 228, 136, 217, 231, 137, 225, 27, 131, 73, 76,
  50                 63, 248, 254, 141, 83, 170, 144, 202, 216, 133, 97,
  51                 32, 113, 103, 164, 45, 43, 9, 91, 203, 155, 37, 208,
  52                 190, 229, 108, 82, 89, 166, 116, 210, 230, 244, 180,
  53                 192, 209, 102, 175, 194, 57, 75, 99, 182,
  54         }
  55         piInv [256]byte
  56         cBlk  [32]*[BlockSize]byte
  57 )
  58
  59 func gf(a, b byte) (c byte) {
  60         for b > 0 {
  61                 if b&1 > 0 {
  62                         c ^= a
  63                 }
  64                 if a&0x80 > 0 {
  65                         a = (a << 1) ^ 0xC3
  66                 } else {
  67                         a <<= 1
  68                 }
  69                 b >>= 1
  70         }
  71         return
  72 }
  73
  74 func l(blk *[BlockSize]byte, rounds int) {
  75         var t byte
  76         var i int
  77         for ; rounds > 0; rounds-- {
  78                 t = blk[15]
  79                 for i = 14; i >= 0; i-- {
  80                         blk[i+1] = blk[i]
  81                         t ^= gf(blk[i], lc[i])
  82                 }
  83                 blk[0] = t
  84         }
  85 }
  86
  87 func lInv(blk *[BlockSize]byte) {
  88         var t byte
  89         var i int
  90         for n := 0; n < BlockSize; n++ {
  91                 t = blk[0]
  92                 for i = 0; i < 15; i++ {
  93                         blk[i] = blk[i+1]
  94                         t ^= gf(blk[i], lc[i])
  95                 }
  96                 blk[15] = t
  97         }
  98 }
  99
 100 func init() {
 101         piInvP := new([256]byte)
 102         for i := 0; i < 256; i++ {
 103                 piInvP[int(pi[i])] = byte(i)
 104         }
 105         piInv = *piInvP
 106         CP := new([32]*[BlockSize]byte)
 107         for i := 0; i < 32; i++ {
 108                 CP[i] = new([BlockSize]byte)
 109                 CP[i][15] = byte(i) + 1
 110                 l(CP[i], 16)
 111         }
 112         cBlk = *CP
 113 }
 114
 115 func s(blk *[BlockSize]byte) {
 116         for i := 0; i < BlockSize; i++ {
 117                 blk[i] = pi[int(blk[i])]
 118         }
 119 }
 120
 121 func xor(dst, src1, src2 *[BlockSize]byte) {
 122         for i := 0; i < BlockSize; i++ {
 123                 dst[i] = src1[i] ^ src2[i]
 124         }
 125 }
 126
 127 type Cipher struct {
 128         ks [10]*[BlockSize]byte
 129 }
 130
 131 func (c *Cipher) BlockSize() int {
 132         return BlockSize
 133 }
 134
 135 func NewCipher(key []byte) *Cipher {
 136         if len(key) != KeySize {
 137                 panic("invalid key size")
 138         }
 139         ks := new([10]*[BlockSize]byte)
 140         kr0 := new([BlockSize]byte)
 141         kr1 := new([BlockSize]byte)
 142         krt := new([BlockSize]byte)
 143         copy(kr0[:], key[:BlockSize])
 144         copy(kr1[:], key[BlockSize:])
 145         ks[0] = new([BlockSize]byte)
 146         ks[1] = new([BlockSize]byte)
 147         copy(ks[0][:], kr0[:])
 148         copy(ks[1][:], kr1[:])
 149         for i := 0; i < 4; i++ {
 150                 for j := 0; j < 8; j++ {
 151                         xor(krt, kr0, cBlk[8*i+j])
 152                         s(krt)
 153                         l(krt, 16)
 154                         xor(krt, krt, kr1)
 155                         copy(kr1[:], kr0[:])
 156                         copy(kr0[:], krt[:])
 157                 }
 158                 ks[2+2*i] = new([BlockSize]byte)
 159                 copy(ks[2+2*i][:], kr0[:])
 160                 ks[2+2*i+1] = new([BlockSize]byte)
 161                 copy(ks[2+2*i+1][:], kr1[:])
 162         }
 163         return &Cipher{*ks}
 164 }
 165
 166 func (c *Cipher) Encrypt(dst, src []byte) {
 167         blk := new([BlockSize]byte)
 168         copy(blk[:], src)
 169         for i := 0; i < 9; i++ {
 170                 xor(blk, blk, c.ks[i])
 171                 s(blk)
 172                 l(blk, 16)
 173         }
 174         xor(blk, blk, c.ks[9])
 175         copy(dst[:BlockSize], blk[:])
 176 }
 177
 178 func (c *Cipher) Decrypt(dst, src []byte) {
 179         blk := new([BlockSize]byte)
 180         copy(blk[:], src)
 181         var n int
 182         for i := 9; i > 0; i-- {
 183                 xor(blk, blk, c.ks[i])
 184                 lInv(blk)
 185                 for n = 0; n < BlockSize; n++ {
 186                         blk[n] = piInv[int(blk[n])]
 187                 }
 188         }
 189         xor(blk, blk, c.ks[0])
 190         copy(dst[:BlockSize], blk[:])
 191 }