crypto.go

package main

import (
	"bytes"
	"crypto/aes"
	"crypto/cipher"
	"crypto/md5"
	"crypto/rand"
	"crypto/sha256"
	"encoding/base64"
	"encoding/hex"
	"errors"
)

func generateRandomBytes(size int) (string, error) {
	b := make([]byte, size)
	_, err := rand.Read(b)
	if err != nil {
		return "", err
	}

	return base64.StdEncoding.EncodeToString(b), nil
}

func deriveKey(password string, saltBase64 string, hashMode string) ([]byte, error) {
	salt, err := base64.StdEncoding.DecodeString(saltBase64)

	if err != nil {
		return nil, err
	}

	data := append(salt, []byte(password)...)

	var key []byte

	if hashMode == "SHA256" {
		hash := sha256.Sum256(data)
		key = hash[:]
	} else {
		hash := md5.Sum(data)
		key = append(hash[:], hash[:]...)
	}

	return key, nil
}

func pkcs7pad(data []byte, blockSize int) []byte {
	padding := blockSize - len(data)%blockSize
	padtext := bytes.Repeat([]byte{byte(padding)}, padding)

	return append(data, padtext...)
}

func pkcs7Unpad(data []byte) ([]byte, error) {
	length := len(data)

	if length == 0 {
		return nil, errors.New("padding error: empty data")
	}

	padLen := int(data[length-1])

	if padLen > length || padLen == 0 {
		return nil, errors.New("padding error: invalid padding size")
	}

	for _, v := range data[length-padLen:] {
		if int(v) != padLen {
			return nil, errors.New("padding error: invalid padding bytes")
		}
	}

	return data[:length-padLen], nil
}

func encryptNote(key []byte, plaintext string) (string, string, error) {
	block, err := aes.NewCipher(key)

	if err != nil {
		return "", "", err
	}

	iv := make([]byte, aes.BlockSize)

	if _, err := rand.Read(iv); err != nil {
		return "", "", err
	}

	paddedData := pkcs7pad([]byte(plaintext), aes.BlockSize)

	ciphertext := make([]byte, len(paddedData))
	mode := cipher.NewCBCEncrypter(block, iv)
	mode.CryptBlocks(ciphertext, paddedData)

	return base64.StdEncoding.EncodeToString(iv), base64.StdEncoding.EncodeToString(ciphertext), nil
}

func decryptNote(key []byte, ivBase64 string, ciphertextBase64 string) (string, error) {
	iv, err := base64.StdEncoding.DecodeString(ivBase64)

	if err != nil {
		return "", err
	}

	ciphertext, err := base64.StdEncoding.DecodeString(ciphertextBase64)

	if err != nil {
		return "", err
	}

	block, err := aes.NewCipher(key)

	if err != nil {
		return "", err
	}

	if len(ciphertext)%aes.BlockSize != 0 {
		return "", errors.New("ciphertext is not a multiple of the block size")
	}

	mode := cipher.NewCBCDecrypter(block, iv)
	plaintextPadded := make([]byte, len(ciphertext))
	mode.CryptBlocks(plaintextPadded, ciphertext)

	plaintext, err := pkcs7Unpad(plaintextPadded)

	if err != nil {
		return "", err
	}

	return string(plaintext), nil
}

func computeIntegrityHash(ivBase64, ciphertextBase64, hashMode string) string {
	data := ivBase64 + ciphertextBase64

	if hashMode == "SHA256" {
		hash := sha256.Sum256([]byte(data))
		return hex.EncodeToString(hash[:])
	}

	hash := md5.Sum([]byte(data))
	return hex.EncodeToString(hash[:])
}