11

试图在 Go 中模拟一种基本上是 AES ECB 模式加密的算法。

这是我到目前为止所拥有的

func Decrypt(data []byte) []byte {
    cipher, err := aes.NewCipher([]byte(KEY))
    if err == nil {
        cipher.Decrypt(data, PKCS5Pad(data))
        return data
    }
    return nil
}

我还有一个 PKCS5Padding 算法，它已经过测试并且可以工作，它首先填充数据。我找不到有关如何在 Go AES 包中切换加密模式的任何信息（绝对不在文档中）。

我有另一种语言的代码，这就是我知道这个算法不能正常工作的原因。

编辑：这是我在问题页面上解释的方法

func AESECB(ciphertext []byte) []byte {
    cipher, _ := aes.NewCipher([]byte(KEY))
    fmt.Println("AESing the data")
    bs := 16
    if len(ciphertext)%bs != 0     {
        panic("Need a multiple of the blocksize")
    }

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

这实际上没有返回任何数据，也许我在将其从加密更改为解密时搞砸了

4

5 回答 5

10

电子密码本（“ECB”）是一种非常简单的操作模式。要加密的数据被分成字节块，所有字节块都具有相同的大小。对于每个块，应用密码，在本例中为AES，生成加密块。

下面的代码片段解密 ECB 中的 AES-128 数据（注意块大小为 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 answer很好地解释了原因。

于 2017-01-14T16:59:44.440 回答
7

为什么？我们故意将欧洲央行排除在外：它不安全，如果需要，实施起来也很简单。

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

于 2014-06-05T23:58:00.620 回答
4

我使用了你的代码，所以我觉得有必要向你展示我是如何修复它的。

我正在为 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 的新 [] 字节中。如果您返回，您将获得数据。

这样做很重要，因为 Decrypt 函数一次只能工作一个块大小。

我返回一片，因为我怀疑它被填充了。我是密码学和 Go 的新手，所以任何人都可以随意更正/修改它。

于 2016-05-15T23:42:38.963 回答
1

理想情况下，您希望实现crypto/cipher#BlockMode接口。由于官方不存在，我使用crypto/cipher#NewCB​​CEncrypter作为起点：

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:]
   }
}
于 2021-03-07T02:03:01.730 回答
-2

我对几件事感到困惑。

首先，我需要上述算法的 aes-256 版本，但是当给定密钥的长度为 32 时，显然 aes.Blocksize（即 16）不会改变。因此，给出长度为 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])
}
于 2017-11-01T11:16:49.043 回答