gost34112012256/tlstree_test.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, version 3 of the License.
   7 //
   8 // This program is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 // GNU General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU General Public License
  14 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15
  16 package gost34112012256
  17
  18 import (
  19         "bytes"
  20         "testing"
  21 )
  22
  23 func TestTLSTreeMagmaCTROMAC(t *testing.T) {
  24         tt := NewTLSTree(TLSGOSTR341112256WithMagmaCTROMAC, []byte{
  25                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  26                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  27                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  28                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  29         })
  30         t.Run("0", func(t *testing.T) {
  31                 got := tt.Derive(0)
  32                 if bytes.Compare(got, []byte{
  33                         0x50, 0x76, 0x42, 0xD9, 0x58, 0xC5, 0x20, 0xC6,
  34                         0xD7, 0xEE, 0xF5, 0xCA, 0x8A, 0x53, 0x16, 0xD4,
  35                         0xF3, 0x4B, 0x85, 0x5D, 0x2D, 0xD4, 0xBC, 0xBF,
  36                         0x4E, 0x5B, 0xF0, 0xFF, 0x64, 0x1A, 0x19, 0xFF,
  37                 }) != 0 {
  38                         t.FailNow()
  39                 }
  40                 if bytes.Compare(got, tt.Derive(1)) != 0 {
  41                         t.FailNow()
  42                 }
  43         })
  44         t.Run("4095", func(t *testing.T) {
  45                 if bytes.Compare(tt.Derive(4095), []byte{
  46                         0x50, 0x76, 0x42, 0xD9, 0x58, 0xC5, 0x20, 0xC6,
  47                         0xD7, 0xEE, 0xF5, 0xCA, 0x8A, 0x53, 0x16, 0xD4,
  48                         0xF3, 0x4B, 0x85, 0x5D, 0x2D, 0xD4, 0xBC, 0xBF,
  49                         0x4E, 0x5B, 0xF0, 0xFF, 0x64, 0x1A, 0x19, 0xFF,
  50                 }) != 0 {
  51                         t.FailNow()
  52                 }
  53         })
  54         t.Run("4096", func(t *testing.T) {
  55                 if bytes.Compare(tt.Derive(4096), []byte{
  56                         0x71, 0x86, 0x93, 0xEC, 0xD3, 0xF1, 0xDC, 0xE2,
  57                         0x11, 0x93, 0xBD, 0x56, 0x40, 0x6A, 0xA4, 0xE2,
  58                         0x09, 0x0F, 0xE1, 0xC8, 0x7A, 0x5D, 0x5D, 0x7A,
  59                         0x8C, 0xE6, 0xE0, 0xD8, 0x28, 0xA4, 0x39, 0x15,
  60                 }) != 0 {
  61                         t.FailNow()
  62                 }
  63         })
  64         t.Run("33554431", func(t *testing.T) {
  65                 if bytes.Compare(tt.Derive(33554431), []byte{
  66                         0xCD, 0x4E, 0x6F, 0x09, 0x94, 0xC4, 0xCA, 0x17,
  67                         0xA9, 0xAD, 0xE5, 0x3D, 0x69, 0x20, 0x49, 0x77,
  68                         0x57, 0x87, 0x3B, 0xC0, 0x8D, 0x4F, 0x98, 0x06,
  69                         0xE3, 0xC9, 0x99, 0xA7, 0xE4, 0xAE, 0x70, 0xE0,
  70                 }) != 0 {
  71                         t.FailNow()
  72                 }
  73         })
  74         t.Run("33554432", func(t *testing.T) {
  75                 if bytes.Compare(tt.Derive(33554432), []byte{
  76                         0x4E, 0xAB, 0x0F, 0x8A, 0x28, 0x2D, 0xE5, 0x78,
  77                         0x85, 0x7B, 0xE0, 0x15, 0xD1, 0x32, 0xCD, 0xFD,
  78                         0x88, 0xF0, 0xEB, 0xD9, 0x9D, 0x10, 0xCC, 0xA3,
  79                         0xB6, 0xD9, 0x11, 0x4E, 0x37, 0x56, 0x5D, 0xE7,
  80                 }) != 0 {
  81                         t.FailNow()
  82                 }
  83         })
  84         t.Run("274877906943", func(t *testing.T) {
  85                 if bytes.Compare(tt.Derive(274877906943), []byte{
  86                         0x37, 0x06, 0xB1, 0xBE, 0xE6, 0xF3, 0xBE, 0xDB,
  87                         0x74, 0x66, 0x4E, 0x1C, 0x43, 0x40, 0xB5, 0xE1,
  88                         0x81, 0x5F, 0xFA, 0x87, 0xEA, 0x80, 0xF4, 0x0E,
  89                         0xAF, 0xCC, 0x28, 0xEF, 0x30, 0xDD, 0xF3, 0xBB,
  90                 }) != 0 {
  91                         t.FailNow()
  92                 }
  93         })
  94         t.Run("274877906944", func(t *testing.T) {
  95                 if bytes.Compare(tt.Derive(274877906944), []byte{
  96                         0x9B, 0xE5, 0x7C, 0xB5, 0x2F, 0x46, 0xB6, 0x0C,
  97                         0x68, 0x40, 0xCD, 0x4E, 0x95, 0x9A, 0x16, 0x8A,
  98                         0x74, 0x82, 0x2C, 0x1D, 0x00, 0x6A, 0xC7, 0x46,
  99                         0xDA, 0xBB, 0xB9, 0x84, 0x8E, 0xB0, 0xA5, 0x8A,
 100                 }) != 0 {
 101                         t.FailNow()
 102                 }
 103         })
 104 }
 105
 106 func TestTLSTreeKuznyechikCTROMAC(t *testing.T) {
 107         tt := NewTLSTree(TLSGOSTR341112256WithKuznyechikCTROMAC, []byte{
 108                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 109                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 110                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 111                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 112         })
 113         t.Run("0", func(t *testing.T) {
 114                 got := tt.Derive(0)
 115                 if bytes.Compare(got, []byte{
 116                         0x50, 0x76, 0x42, 0xD9, 0x58, 0xC5, 0x20, 0xC6,
 117                         0xD7, 0xEE, 0xF5, 0xCA, 0x8A, 0x53, 0x16, 0xD4,
 118                         0xF3, 0x4B, 0x85, 0x5D, 0x2D, 0xD4, 0xBC, 0xBF,
 119                         0x4E, 0x5B, 0xF0, 0xFF, 0x64, 0x1A, 0x19, 0xFF,
 120                 }) != 0 {
 121                         t.FailNow()
 122                 }
 123                 if bytes.Compare(got, tt.Derive(1)) != 0 {
 124                         t.FailNow()
 125                 }
 126         })
 127         t.Run("63", func(t *testing.T) {
 128                 if bytes.Compare(tt.Derive(63), []byte{
 129                         0x50, 0x76, 0x42, 0xD9, 0x58, 0xC5, 0x20, 0xC6,
 130                         0xD7, 0xEE, 0xF5, 0xCA, 0x8A, 0x53, 0x16, 0xD4,
 131                         0xF3, 0x4B, 0x85, 0x5D, 0x2D, 0xD4, 0xBC, 0xBF,
 132                         0x4E, 0x5B, 0xF0, 0xFF, 0x64, 0x1A, 0x19, 0xFF,
 133                 }) != 0 {
 134                         t.FailNow()
 135                 }
 136         })
 137         t.Run("64", func(t *testing.T) {
 138                 if bytes.Compare(tt.Derive(64), []byte{
 139                         0xC1, 0x9B, 0x63, 0x9F, 0x4B, 0xEA, 0x78, 0x8C,
 140                         0x1C, 0x59, 0xB4, 0xC8, 0x87, 0xDB, 0x5B, 0x07,
 141                         0xC1, 0x91, 0x19, 0x10, 0x18, 0x68, 0xDA, 0xB8,
 142                         0x9A, 0x8D, 0x93, 0x61, 0xB2, 0xF0, 0x10, 0xF3,
 143                 }) != 0 {
 144                         t.FailNow()
 145                 }
 146         })
 147         t.Run("524287", func(t *testing.T) {
 148                 if bytes.Compare(tt.Derive(524287), []byte{
 149                         0x92, 0x30, 0x3E, 0xB5, 0x61, 0x56, 0x88, 0x54,
 150                         0xE3, 0x3E, 0x4F, 0xE0, 0x97, 0xA9, 0x95, 0x99,
 151                         0x17, 0x9F, 0x5B, 0x90, 0x94, 0xAE, 0x34, 0x79,
 152                         0xE6, 0x1C, 0x43, 0x69, 0x3A, 0x3F, 0x0A, 0x06,
 153                 }) != 0 {
 154                         t.FailNow()
 155                 }
 156         })
 157         t.Run("524288", func(t *testing.T) {
 158                 if bytes.Compare(tt.Derive(524288), []byte{
 159                         0xE8, 0x55, 0xA0, 0xE2, 0xCB, 0xDD, 0x68, 0xC1,
 160                         0x13, 0x7C, 0xEF, 0x3E, 0x80, 0x1E, 0x0B, 0xFF,
 161                         0x68, 0x62, 0x8C, 0x36, 0x43, 0x68, 0x27, 0x6D,
 162                         0x0C, 0xB8, 0x7E, 0xB5, 0x6E, 0x94, 0xEF, 0x42,
 163                 }) != 0 {
 164                         t.FailNow()
 165                 }
 166         })
 167         t.Run("4294967295", func(t *testing.T) {
 168                 if bytes.Compare(tt.Derive(4294967295), []byte{
 169                         0x93, 0xD3, 0xCA, 0xE9, 0x5A, 0x55, 0xB7, 0x1A,
 170                         0xA3, 0xB9, 0xA7, 0xDD, 0xF9, 0x9A, 0x6A, 0xAC,
 171                         0x3F, 0xDA, 0x17, 0x2A, 0x79, 0x60, 0x58, 0x04,
 172                         0xA9, 0xC9, 0xFC, 0x6E, 0x84, 0x8A, 0xF1, 0xAA,
 173                 }) != 0 {
 174                         t.FailNow()
 175                 }
 176         })
 177         t.Run("4294967296", func(t *testing.T) {
 178                 if bytes.Compare(tt.Derive(4294967296), []byte{
 179                         0x7F, 0xFB, 0x1A, 0xD7, 0xE5, 0x7B, 0x70, 0xBE,
 180                         0x10, 0x96, 0x31, 0xD2, 0x71, 0x92, 0x98, 0xB9,
 181                         0x7D, 0xEE, 0x3B, 0x00, 0x8D, 0x86, 0xF8, 0x3D,
 182                         0xAA, 0xF6, 0x2A, 0x4E, 0xA5, 0xB7, 0xAA, 0xFD,
 183                 }) != 0 {
 184                         t.FailNow()
 185                 }
 186         })
 187 }