Golang: How do I decrypt with DES, CBC, and PKCS7?

Question

Currently trying to figure out why my decryption method is not working. I used DES, CBC, and PKCS7Padding to encrypt my string. My current code outputs panic: crypto/cipher: input not full blocks during decryption.

Answer 1

Buddy it's work completely fine.

package main

    import (
        "bytes"
        "crypto/des"
        "crypto/cipher"
        "fmt"
    )

    func DesEncryption(key, iv, plainText []byte) ([]byte, error) {

        block, err := des.NewCipher(key)

        if err != nil {
            return nil, err
        }

        blockSize := block.BlockSize()
        origData := PKCS5Padding(plainText, blockSize)
        blockMode := cipher.NewCBCEncrypter(block, iv)
        cryted := make([]byte, len(origData))
        blockMode.CryptBlocks(cryted, origData)
        return cryted, nil
    }

    func DesDecryption(key, iv, cipherText []byte) ([]byte, error) {

        block, err := des.NewCipher(key)

        if err != nil {
            return nil, err
        }

        blockMode := cipher.NewCBCDecrypter(block, iv)
        origData := make([]byte, len(cipherText))
        blockMode.CryptBlocks(origData, cipherText)
        origData = PKCS5UnPadding(origData)
        return origData, nil
    }

    func PKCS5Padding(src []byte, blockSize int) []byte {
        padding := blockSize - len(src)%blockSize
        padtext := bytes.Repeat([]byte{byte(padding)}, padding)
        return append(src, padtext...)
    }

    func PKCS5UnPadding(src []byte) []byte {
        length := len(src)
        unpadding := int(src[length-1])
        return src[:(length - unpadding)]
    }


    func main() {
        originalText := "sysys"
        fmt.Println(originalText)
        mytext := []byte(originalText)

        key := []byte{0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC }
        iv := []byte{0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC }


        cryptoText,_ := DesEncryption(key, iv, mytext)
        fmt.Println(string(cryptoText))
        decryptedText,_ := DesDecryption(key, iv, cryptoText)
        fmt.Println(string(decryptedText))

    }

Answer 2

you can do like this

package controllers

import (
    "bytes"
    "crypto/aes"
    "crypto/cipher"
    "encoding/hex"
    "fmt"
)

func PKCS7Padding(ciphertext []byte) []byte {
    padding := aes.BlockSize - len(ciphertext) % aes.BlockSize
    padtext := bytes.Repeat([]byte{byte(padding)}, padding)
    return append(ciphertext, padtext...)
}

func PKCS7UnPadding(plantText []byte) []byte {
    length   := len(plantText)
    unpadding := int(plantText[length-1])
    return plantText[:(length - unpadding)]
}

func OpensslDecrypt(keyStr string, ivStr string, text string) string{

    key, _ := hex.DecodeString(keyStr);
    iv, _ := hex.DecodeString(ivStr);
    ciphertext, _ := hex.DecodeString(text);

    block, err := aes.NewCipher(key)
    if err != nil {
        panic(err)
    }
    plaintext := make([]byte,len(ciphertext))
    mode := cipher.NewCBCDecrypter(block, iv)
    mode.CryptBlocks(plaintext, ciphertext)

    plaintext = PKCS7UnPadding(plaintext)
    return fmt.Sprintf("%s\n", plaintext)
}

func OpensslEncrypt(keyStr string, ivStr string, text string) string{

    plaintext := []byte(text)
    key, _ := hex.DecodeString(keyStr);
    iv, _ := hex.DecodeString(ivStr);

    plaintext = PKCS7Padding(plaintext);
    ciphertext := make([]byte,len(plaintext))
    block, err := aes.NewCipher(key)
    if err != nil {
        panic(err)
    }

    mode := cipher.NewCBCEncrypter(block, iv)
    mode.CryptBlocks(ciphertext, plaintext)

    return fmt.Sprintf("%x\n", ciphertext)
}