Шифрование Golang AES ECB

Электронная кодовая книга (ECB) - это очень простой режим работы. Данные, подлежащие шифрованию, делятся на байтовые блоки одинакового размера. Для каждого блока применяется шифр, в данном случае AES, генерирующий зашифрованный блок.

Приведенный ниже фрагмент кода расшифровывает данные AES-128 в ECB (обратите внимание, что размер блока составляет 16 байт):

package main

import (
    "crypto/aes"
)

func DecryptAes128Ecb(data, key []byte) []byte {
    cipher, _ := aes.NewCipher([]byte(key))
    decrypted := make([]byte, len(data))
    size := 16

    for bs, be := 0, size; bs < len(data); bs, be = bs+size, be+size {
        cipher.Decrypt(decrypted[bs:be], data[bs:be])
    }

    return decrypted
}

Как упоминалось в @OneOfOne, ECB небезопасен и его очень легко обнаружить, поскольку повторяющиеся блоки всегда будут шифроваться одними и теми же зашифрованными блоками. Этот ответ Crypto SE дает очень хорошее объяснение почему.

Почему? Мы намеренно исключили ECB: он небезопасен, а при необходимости его легко реализовать.

https://github.com/golang/go/issues/5597

Я использовал ваш код, поэтому считаю необходимым показать вам, как я его исправил.

Я выполняю задачи шифрования для этой проблемы в Go.

Я объясню вам ошибку, поскольку код в основном правильный.

for len(plaintext) > 0 {
    cipher.Decrypt(plaintext, ciphertext)
    plaintext = plaintext[bs:]
    ciphertext = ciphertext[bs:]
}

Цикл расшифровывает данные, но никуда их не помещает. Он просто сдвигает два массива без вывода.

i := 0
plaintext := make([]byte, len(ciphertext))
finalplaintext := make([]byte, len(ciphertext))
for len(ciphertext) > 0 {
    cipher.Decrypt(plaintext, ciphertext)
    ciphertext = ciphertext[bs:]
    decryptedBlock := plaintext[:bs]
    for index, element := range decryptedBlock {
        finalplaintext[(i*bs)+index] = element
    }
    i++
    plaintext = plaintext[bs:]
} 
return finalplaintext[:len(finalplaintext)-5]

Это новое улучшение сохраняет расшифрованные данные в новом [] байте, называемом finalplaintext. Если вы вернетесь, вы получите данные.

Это важно сделать таким образом, поскольку функция дешифрования работает только с одним размером блока за раз.

Я возвращаю кусок, потому что подозреваю, что он набит. Я новичок в криптографии и Go, поэтому любой может исправить / пересмотреть это.

В идеале вы хотите реализовать интерфейс crypto / cipher # BlockMode. Поскольку официального не существует, я использовал crypto / cipher # NewCBCEncrypter в качестве отправной точки:

package ecb
import "crypto/cipher"

type ecbEncrypter struct { cipher.Block }

func newECBEncrypter(b cipher.Block) cipher.BlockMode {
   return ecbEncrypter{b}
}

func (x ecbEncrypter) BlockSize() int {
   return x.Block.BlockSize()
}

func (x ecbEncrypter) CryptBlocks(dst, src []byte) {
   size := x.BlockSize()
   if len(src) % size != 0 {
      panic("crypto/cipher: input not full blocks")
   }
   if len(dst) < len(src) {
      panic("crypto/cipher: output smaller than input")
   }
   for len(src) > 0 {
      x.Encrypt(dst, src)
      src, dst = src[size:], dst[size:]
   }
}

Меня смутило несколько вещей.

Сначала мне нужна была версия вышеупомянутого алгоритма aes-256, но, очевидно, aes.Blocksize (который равен 16) не изменится, когда заданный ключ имеет длину 32. Так что достаточно дать ключ длиной 32, чтобы сделать алгоритм aes-256

Во-вторых, расшифрованное значение по-прежнему содержит заполнение, а значение заполнения изменяется в зависимости от длины зашифрованной строки. Например. когда есть 5 символов заполнения, сам символ заполнения будет 5.

Вот моя функция, которая возвращает строку:

func DecryptAes256Ecb(hexString string, key string) string {
  data, _ := hex.DecodeString(hexString)

  cipher, _ := aes.NewCipher([]byte(key))

  decrypted := make([]byte, len(data))
  size := 16

  for bs, be := 0, size; bs < len(data); bs, be = bs+size, be+size {
    cipher.Decrypt(decrypted[bs:be], data[bs:be])
  }

  // remove the padding. The last character in the byte array is the number of padding chars
  paddingSize := int(decrypted[len(decrypted)-1])
  return string(decrypted[0 : len(decrypted)-paddingSize])
}