140 lines
3.5 KiB
Go
140 lines
3.5 KiB
Go
package cryptext
|
|
|
|
import (
|
|
"git.blackforestbytes.com/BlackForestBytes/goext/tst"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestAESSimpleEmptyData(t *testing.T) {
|
|
pw := []byte("password")
|
|
enc, err := EncryptAESSimple(pw, []byte{}, 256)
|
|
tst.AssertNoErr(t, err)
|
|
tst.AssertNotEqual(t, enc, "")
|
|
|
|
dec, err := DecryptAESSimple(pw, enc)
|
|
tst.AssertNoErr(t, err)
|
|
tst.AssertEqual(t, len(dec), 0)
|
|
}
|
|
|
|
func TestAESSimpleEmptyPassword(t *testing.T) {
|
|
pw := []byte{}
|
|
plain := []byte("some content")
|
|
|
|
enc, err := EncryptAESSimple(pw, plain, 256)
|
|
tst.AssertNoErr(t, err)
|
|
|
|
dec, err := DecryptAESSimple(pw, enc)
|
|
tst.AssertNoErr(t, err)
|
|
tst.AssertEqual(t, string(dec), string(plain))
|
|
}
|
|
|
|
func TestAESSimpleWrongPassword(t *testing.T) {
|
|
plain := []byte("Hello World")
|
|
enc, err := EncryptAESSimple([]byte("right"), plain, 256)
|
|
tst.AssertNoErr(t, err)
|
|
|
|
_, err = DecryptAESSimple([]byte("wrong"), enc)
|
|
if err == nil {
|
|
t.Errorf("expected error when decrypting with wrong password")
|
|
}
|
|
}
|
|
|
|
func TestAESSimpleInvalidBase32(t *testing.T) {
|
|
_, err := DecryptAESSimple([]byte("pw"), "!!!not-base32!!!")
|
|
if err == nil {
|
|
t.Errorf("expected error on invalid base32 input")
|
|
}
|
|
}
|
|
|
|
func TestAESSimpleInvalidJSON(t *testing.T) {
|
|
// "AAAAAAAA" decodes to valid base32 but not valid JSON
|
|
_, err := DecryptAESSimple([]byte("pw"), "AAAAAAAA")
|
|
if err == nil {
|
|
t.Errorf("expected error on invalid JSON payload")
|
|
}
|
|
}
|
|
|
|
func TestAESSimpleEmptyEncText(t *testing.T) {
|
|
_, err := DecryptAESSimple([]byte("pw"), "")
|
|
if err == nil {
|
|
t.Errorf("expected error on empty text")
|
|
}
|
|
}
|
|
|
|
func TestAESSimpleLargeData(t *testing.T) {
|
|
pw := []byte("hunter12")
|
|
plain := []byte(strings.Repeat("ABCDEFGHIJ", 1024))
|
|
|
|
enc, err := EncryptAESSimple(pw, plain, 256)
|
|
tst.AssertNoErr(t, err)
|
|
|
|
dec, err := DecryptAESSimple(pw, enc)
|
|
tst.AssertNoErr(t, err)
|
|
tst.AssertEqual(t, string(dec), string(plain))
|
|
}
|
|
|
|
func TestAESSimpleBinaryData(t *testing.T) {
|
|
pw := []byte("hunter12")
|
|
plain := []byte{0x00, 0x01, 0x02, 0x7F, 0x80, 0xFE, 0xFF, 0x00, 0xAA, 0x55}
|
|
|
|
enc, err := EncryptAESSimple(pw, plain, 256)
|
|
tst.AssertNoErr(t, err)
|
|
|
|
dec, err := DecryptAESSimple(pw, enc)
|
|
tst.AssertNoErr(t, err)
|
|
tst.AssertArrayEqual(t, dec, plain)
|
|
}
|
|
|
|
func TestAESSimpleDifferentRoundsForEachCall(t *testing.T) {
|
|
pw := []byte("hunter12")
|
|
plain := []byte("Hello")
|
|
|
|
enc1, err := EncryptAESSimple(pw, plain, 256)
|
|
tst.AssertNoErr(t, err)
|
|
|
|
enc2, err := EncryptAESSimple(pw, plain, 256)
|
|
tst.AssertNoErr(t, err)
|
|
|
|
// Two separate encrypt calls on same plaintext should differ (random salt + IV)
|
|
tst.AssertNotEqual(t, enc1, enc2)
|
|
|
|
// Both should decrypt back to the same plaintext
|
|
d1, err := DecryptAESSimple(pw, enc1)
|
|
tst.AssertNoErr(t, err)
|
|
d2, err := DecryptAESSimple(pw, enc2)
|
|
tst.AssertNoErr(t, err)
|
|
tst.AssertEqual(t, string(d1), string(plain))
|
|
tst.AssertEqual(t, string(d2), string(plain))
|
|
}
|
|
|
|
func TestAESSimpleVariableRounds(t *testing.T) {
|
|
pw := []byte("hunter12")
|
|
plain := []byte("rounds-test")
|
|
|
|
for _, r := range []int{16, 32, 64, 128, 256, 512, 1024} {
|
|
enc, err := EncryptAESSimple(pw, plain, r)
|
|
tst.AssertNoErr(t, err)
|
|
dec, err := DecryptAESSimple(pw, enc)
|
|
tst.AssertNoErr(t, err)
|
|
tst.AssertEqual(t, string(dec), string(plain))
|
|
}
|
|
}
|
|
|
|
func TestAESSimpleResultIsBase32(t *testing.T) {
|
|
pw := []byte("hunter12")
|
|
plain := []byte("Hello World")
|
|
|
|
enc, err := EncryptAESSimple(pw, plain, 64)
|
|
tst.AssertNoErr(t, err)
|
|
|
|
for _, c := range enc {
|
|
isUpper := c >= 'A' && c <= 'Z'
|
|
isDigit := c >= '2' && c <= '7'
|
|
if !(isUpper || isDigit) {
|
|
t.Errorf("non-base32 character %q in output", c)
|
|
break
|
|
}
|
|
}
|
|
}
|