stupidgcm: introduce stupidAEADCommon and use for both chacha & gcm

Nice deduplication and brings the GCM decrypt speed up to par.

internal/speed$ benchstat old new
name                old time/op   new time/op   delta
StupidGCM-4          4.71µs ± 0%   4.66µs ± 0%   -0.99%  (p=0.008 n=5+5)
StupidGCMDecrypt-4   5.77µs ± 1%   4.51µs ± 0%  -21.80%  (p=0.008 n=5+5)

name                old speed     new speed     delta
StupidGCM-4         870MB/s ± 0%  879MB/s ± 0%   +1.01%  (p=0.008 n=5+5)
StupidGCMDecrypt-4  710MB/s ± 1%  908MB/s ± 0%  +27.87%  (p=0.008 n=5+5)
master
Jakob Unterwurzacher 1 year ago
parent bf572aef88
commit e2ec048a09
  1. 35
      internal/stupidgcm/chacha.go
  2. 0
      internal/stupidgcm/chacha_test.go
  3. 68
      internal/stupidgcm/common.go
  4. 17
      internal/stupidgcm/common_test.go
  5. 45
      internal/stupidgcm/gcm.go
  6. 0
      internal/stupidgcm/gcm_test.go
  7. 108
      internal/stupidgcm/openssl.go
  8. 26
      internal/stupidgcm/openssl_aead.c
  9. 13
      internal/stupidgcm/openssl_aead.h
  10. 156
      internal/stupidgcm/stupidchacha.go
  11. 204
      internal/stupidgcm/stupidgcm.go
  12. 10
      internal/stupidgcm/xchacha.go
  13. 0
      internal/stupidgcm/xchacha_test.go

@ -0,0 +1,35 @@
// +build !without_openssl
package stupidgcm
import (
"crypto/cipher"
"log"
"golang.org/x/crypto/chacha20poly1305"
)
/*
#include <openssl/evp.h>
*/
import "C"
type stupidChacha20poly1305 struct {
stupidAEADCommon
}
// Verify that we satisfy the cipher.AEAD interface
var _ cipher.AEAD = &stupidChacha20poly1305{}
func newChacha20poly1305(key []byte) *stupidChacha20poly1305 {
if len(key) != chacha20poly1305.KeySize {
log.Panicf("Only %d-byte keys are supported, you passed %d bytes", chacha20poly1305.KeySize, len(key))
}
return &stupidChacha20poly1305{
stupidAEADCommon{
key: append([]byte{}, key...), // private copy
openSSLEVPCipher: C.EVP_chacha20_poly1305(),
nonceSize: chacha20poly1305.NonceSize,
},
}
}

@ -0,0 +1,68 @@
package stupidgcm
import (
"log"
)
/*
#include <openssl/evp.h>
*/
import "C"
type stupidAEADCommon struct {
wiped bool
key []byte
openSSLEVPCipher *C.EVP_CIPHER
nonceSize int
}
// Overhead returns the number of bytes that are added for authentication.
//
// Part of the cipher.AEAD interface.
func (c *stupidAEADCommon) Overhead() int {
return tagLen
}
// NonceSize returns the required size of the nonce / IV
//
// Part of the cipher.AEAD interface.
func (c *stupidAEADCommon) NonceSize() int {
return c.nonceSize
}
// Seal encrypts "in" using "iv" and "authData" and append the result to "dst"
//
// Part of the cipher.AEAD interface.
func (c *stupidAEADCommon) Seal(dst, iv, in, authData []byte) []byte {
return openSSLSeal(c, dst, iv, in, authData)
}
// Open decrypts "in" using "iv" and "authData" and append the result to "dst"
//
// Part of the cipher.AEAD interface.
func (c *stupidAEADCommon) Open(dst, iv, in, authData []byte) ([]byte, error) {
return openSSLOpen(c, dst, iv, in, authData)
}
// Wipe tries to wipe the key from memory by overwriting it with zeros.
//
// This is not bulletproof due to possible GC copies, but
// still raises the bar for extracting the key.
func (c *stupidAEADCommon) Wipe() {
key := c.key
c.wiped = true
c.key = nil
for i := range key {
key[i] = 0
}
}
func (c *stupidAEADCommon) Wiped() bool {
if c.wiped {
return true
}
if len(c.key) != keyLen {
log.Panicf("wrong key length %d", len(c.key))
}
return false
}

@ -162,25 +162,26 @@ func testCorruption(t *testing.T, c cipher.AEAD) {
}
}
type Wiper interface {
Wipe()
}
func testWipe(t *testing.T, c cipher.AEAD) {
switch c2 := c.(type) {
case *StupidGCM:
c2.Wipe()
if c2.key != nil {
t.Fatal("key is not nil")
if !c2.Wiped() {
t.Error("c2.wiped is not set")
}
for _, v := range c2.key {
if v != 0 {
t.Fatal("c2._key is not zeroed")
}
}
case *stupidChacha20poly1305:
c2.Wipe()
if !c2.wiped {
if !c2.Wiped() {
t.Error("c2.wiped is not set")
}
for _, v := range c2.key {
if v != 0 {
t.Fatal("c2.key is not zeroed")
t.Fatal("c2._key is not zeroed")
}
}
case *stupidXchacha20poly1305:

@ -0,0 +1,45 @@
// +build !without_openssl
// Package stupidgcm is a thin wrapper for OpenSSL's GCM encryption and
// decryption functions. It only support 32-byte keys and 16-bit IVs.
package stupidgcm
// #include <openssl/evp.h>
import "C"
import (
"crypto/cipher"
"log"
)
const (
// BuiltWithoutOpenssl indicates if openssl been disabled at compile-time
BuiltWithoutOpenssl = false
keyLen = 32
ivLen = 16
tagLen = 16
)
// StupidGCM implements the cipher.AEAD interface
type StupidGCM struct {
stupidAEADCommon
}
// Verify that we satisfy the interface
var _ cipher.AEAD = &StupidGCM{}
// New returns a new cipher.AEAD implementation..
func New(keyIn []byte, forceDecode bool) cipher.AEAD {
if len(keyIn) != keyLen {
log.Panicf("Only %d-byte keys are supported", keyLen)
}
return &StupidGCM{
stupidAEADCommon{
// Create a private copy of the key
key: append([]byte{}, keyIn...),
openSSLEVPCipher: C.EVP_aes_256_gcm(),
nonceSize: ivLen,
},
}
}

@ -0,0 +1,108 @@
package stupidgcm
import (
"fmt"
"log"
)
/*
#include "openssl_aead.h"
#cgo pkg-config: libcrypto
*/
import "C"
func openSSLSeal(a *stupidAEADCommon, dst, iv, in, authData []byte) []byte {
if a.Wiped() {
panic("BUG: tried to use wiped key")
}
if len(iv) != a.NonceSize() {
log.Panicf("Only %d-byte IVs are supported, you passed %d bytes", a.NonceSize(), len(iv))
}
if len(in) == 0 {
log.Panic("Zero-length input data is not supported")
}
// If the "dst" slice is large enough we can use it as our output buffer
outLen := len(in) + tagLen
var buf []byte
inplace := false
if cap(dst)-len(dst) >= outLen {
inplace = true
buf = dst[len(dst) : len(dst)+outLen]
} else {
buf = make([]byte, outLen)
}
res := int(C.openssl_aead_seal(a.openSSLEVPCipher,
(*C.uchar)(&in[0]),
C.int(len(in)),
(*C.uchar)(&authData[0]),
C.int(len(authData)),
(*C.uchar)(&a.key[0]),
C.int(len(a.key)),
(*C.uchar)(&iv[0]),
C.int(len(iv)),
(*C.uchar)(&buf[0]),
C.int(len(buf))))
if res != outLen {
log.Panicf("expected length %d, got %d", outLen, res)
}
if inplace {
return dst[:len(dst)+outLen]
}
return append(dst, buf...)
}
func openSSLOpen(a *stupidAEADCommon, dst, iv, in, authData []byte) ([]byte, error) {
if a.Wiped() {
panic("BUG: tried to use wiped key")
}
if len(iv) != a.NonceSize() {
log.Panicf("Only %d-byte IVs are supported, you passed %d bytes", a.NonceSize(), len(iv))
}
if len(in) <= tagLen {
return nil, fmt.Errorf("stupidChacha20poly1305: input data too short (%d bytes)", len(in))
}
// If the "dst" slice is large enough we can use it as our output buffer
outLen := len(in) - tagLen
var buf []byte
inplace := false
if cap(dst)-len(dst) >= outLen {
inplace = true
buf = dst[len(dst) : len(dst)+outLen]
} else {
buf = make([]byte, len(in)-tagLen)
}
ciphertext := in[:len(in)-tagLen]
tag := in[len(in)-tagLen:]
res := int(C.openssl_aead_open(a.openSSLEVPCipher,
(*C.uchar)(&ciphertext[0]),
C.int(len(ciphertext)),
(*C.uchar)(&authData[0]),
C.int(len(authData)),
(*C.uchar)(&tag[0]),
C.int(len(tag)),
(*C.uchar)(&a.key[0]),
C.int(len(a.key)),
(*C.uchar)(&iv[0]),
C.int(len(iv)),
(*C.uchar)(&buf[0]),
C.int(len(buf))))
if res < 0 {
return nil, ErrAuth
}
if res != outLen {
log.Panicf("unexpected length %d", res)
}
if inplace {
return dst[:len(dst)+outLen], nil
}
return append(dst, buf...), nil
}

@ -1,4 +1,4 @@
#include "chacha.h"
#include "openssl_aead.h"
#include <openssl/evp.h>
#include <stdio.h>
//#cgo pkg-config: libcrypto
@ -9,24 +9,12 @@ static void panic(const char* const msg)
__builtin_trap();
}
static const EVP_CIPHER* getEvpCipher(enum aeadType cipherId)
{
switch (cipherId) {
case aeadTypeChacha:
return EVP_chacha20_poly1305();
case aeadTypeGcm:
return EVP_aes_256_gcm();
}
panic("unknown cipherId");
return NULL;
}
// We only support 16-byte tags
static const int supportedTagLen = 16;
// https://wiki.openssl.org/index.php/EVP_Authenticated_Encryption_and_Decryption#Authenticated_Encryption_using_GCM_mode
int aead_seal(
const enum aeadType cipherId,
int openssl_aead_seal(
const EVP_CIPHER* evpCipher,
const unsigned char* const plaintext,
const int plaintextLen,
const unsigned char* const authData,
@ -38,8 +26,6 @@ int aead_seal(
unsigned char* const ciphertext,
const int ciphertextBufLen)
{
const EVP_CIPHER* evpCipher = getEvpCipher(cipherId);
// Create scratch space "ctx"
EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
if (!ctx) {
@ -111,8 +97,8 @@ int aead_seal(
return ciphertextLen;
}
int aead_open(
const enum aeadType cipherId,
int openssl_aead_open(
const EVP_CIPHER* evpCipher,
const unsigned char* const ciphertext,
const int ciphertextLen,
const unsigned char* const authData,
@ -126,8 +112,6 @@ int aead_open(
unsigned char* const plaintext,
const int plaintextBufLen)
{
const EVP_CIPHER* evpCipher = getEvpCipher(cipherId);
// Create scratch space "ctx"
EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
if (!ctx) {

@ -1,10 +1,7 @@
enum aeadType {
aeadTypeChacha = 1,
aeadTypeGcm = 2,
};
#include <openssl/evp.h>
int aead_seal(
const enum aeadType cipherId,
int openssl_aead_seal(
const EVP_CIPHER* evpCipher,
const unsigned char* const plaintext,
const int plaintextLen,
const unsigned char* const authData,
@ -16,8 +13,8 @@ int aead_seal(
unsigned char* const ciphertext,
const int ciphertextBufLen);
int aead_open(
const enum aeadType cipherId,
int openssl_aead_open(
const EVP_CIPHER* evpCipher,
const unsigned char* const ciphertext,
const int ciphertextLen,
const unsigned char* const authData,

@ -1,156 +0,0 @@
// +build !without_openssl
package stupidgcm
import (
"crypto/cipher"
"fmt"
"log"
"golang.org/x/crypto/chacha20poly1305"
)
/*
#include <openssl/evp.h>
#include "chacha.h"
#cgo pkg-config: libcrypto
*/
import "C"
type stupidChacha20poly1305 struct {
key [chacha20poly1305.KeySize]byte
wiped bool
}
// Verify that we satisfy the cipher.AEAD interface
var _ cipher.AEAD = &stupidChacha20poly1305{}
func newChacha20poly1305(key []byte) cipher.AEAD {
if len(key) != chacha20poly1305.KeySize {
log.Panicf("Only %d-byte keys are supported, you passed %d bytes", chacha20poly1305.KeySize, len(key))
}
ret := new(stupidChacha20poly1305)
copy(ret.key[:], key)
return ret
}
// NonceSize returns the required size of the nonce / IV.
func (g *stupidChacha20poly1305) NonceSize() int {
return chacha20poly1305.NonceSize
}
// Overhead returns the number of bytes that are added for authentication.
func (g *stupidChacha20poly1305) Overhead() int {
return tagLen
}
// Seal encrypts "in" using "iv" and "authData" and append the result to "dst"
func (g *stupidChacha20poly1305) Seal(dst, iv, in, authData []byte) []byte {
if g.wiped {
panic("BUG: tried to use wiped key")
}
if len(iv) != g.NonceSize() {
log.Panicf("Only %d-byte IVs are supported, you passed %d bytes", g.NonceSize(), len(iv))
}
if len(in) == 0 {
log.Panic("Zero-length input data is not supported")
}
if len(g.key) != chacha20poly1305.KeySize {
log.Panicf("Wrong key length: %d. Key has been wiped?", len(g.key))
}
// If the "dst" slice is large enough we can use it as our output buffer
outLen := len(in) + tagLen
var buf []byte
inplace := false
if cap(dst)-len(dst) >= outLen {
inplace = true
buf = dst[len(dst) : len(dst)+outLen]
} else {
buf = make([]byte, outLen)
}
C.aead_seal(C.aeadTypeChacha,
(*C.uchar)(&in[0]),
C.int(len(in)),
(*C.uchar)(&authData[0]),
C.int(len(authData)),
(*C.uchar)(&g.key[0]),
C.int(len(g.key)),
(*C.uchar)(&iv[0]),
C.int(len(iv)),
(*C.uchar)(&buf[0]),
C.int(len(buf)))
if inplace {
return dst[:len(dst)+outLen]
}
return append(dst, buf...)
}
// Open decrypts "in" using "iv" and "authData" and append the result to "dst"
func (g *stupidChacha20poly1305) Open(dst, iv, in, authData []byte) ([]byte, error) {
if g.wiped {
panic("BUG: tried to use wiped key")
}
if len(iv) != g.NonceSize() {
log.Panicf("Only %d-byte IVs are supported", g.NonceSize())
}
if len(g.key) != chacha20poly1305.KeySize {
log.Panicf("Wrong key length: %d. Key has been wiped?", len(g.key))
}
if len(in) <= tagLen {
return nil, fmt.Errorf("stupidChacha20poly1305: input data too short (%d bytes)", len(in))
}
// If the "dst" slice is large enough we can use it as our output buffer
outLen := len(in) - tagLen
var buf []byte
inplace := false
if cap(dst)-len(dst) >= outLen {
inplace = true
buf = dst[len(dst) : len(dst)+outLen]
} else {
buf = make([]byte, len(in)-tagLen)
}
ciphertext := in[:len(in)-tagLen]
tag := in[len(in)-tagLen:]
res := int(C.aead_open(C.aeadTypeChacha,
(*C.uchar)(&ciphertext[0]),
C.int(len(ciphertext)),
(*C.uchar)(&authData[0]),
C.int(len(authData)),
(*C.uchar)(&tag[0]),
C.int(len(tag)),
(*C.uchar)(&g.key[0]),
C.int(len(g.key)),
(*C.uchar)(&iv[0]),
C.int(len(iv)),
(*C.uchar)(&buf[0]),
C.int(len(buf))))
if res < 0 {
return nil, ErrAuth
}
if res != outLen {
log.Panicf("unexpected length %d", res)
}
if inplace {
return dst[:len(dst)+outLen], nil
}
return append(dst, buf...), nil
}
// Wipe tries to wipe the key from memory by overwriting it with zeros.
//
// This is not bulletproof due to possible GC copies, but
// still raises the bar for extracting the key.
func (g *stupidChacha20poly1305) Wipe() {
g.wiped = true
for i := range g.key {
g.key[i] = 0
}
}

@ -1,204 +0,0 @@
// +build !without_openssl
// Package stupidgcm is a thin wrapper for OpenSSL's GCM encryption and
// decryption functions. It only support 32-byte keys and 16-bit IVs.
package stupidgcm
// #include <openssl/evp.h>
// #include "chacha.h"
// #cgo pkg-config: libcrypto
import "C"
import (
"crypto/cipher"
"fmt"
"log"
"unsafe"
)
const (
// BuiltWithoutOpenssl indicates if openssl been disabled at compile-time
BuiltWithoutOpenssl = false
keyLen = 32
ivLen = 16
tagLen = 16
)
// StupidGCM implements the cipher.AEAD interface
type StupidGCM struct {
key []byte
forceDecode bool
}
// Verify that we satisfy the cipher.AEAD interface
var _ cipher.AEAD = &StupidGCM{}
// New returns a new cipher.AEAD implementation..
func New(keyIn []byte, forceDecode bool) cipher.AEAD {
if len(keyIn) != keyLen {
log.Panicf("Only %d-byte keys are supported", keyLen)
}
// Create a private copy of the key
key := append([]byte{}, keyIn...)
return &StupidGCM{key: key, forceDecode: forceDecode}
}
// NonceSize returns the required size of the nonce / IV.
func (g *StupidGCM) NonceSize() int {
return ivLen
}
// Overhead returns the number of bytes that are added for authentication.
func (g *StupidGCM) Overhead() int {
return tagLen
}
// Seal encrypts "in" using "iv" and "authData" and append the result to "dst"
func (g *StupidGCM) Seal(dst, iv, in, authData []byte) []byte {
if len(iv) != ivLen {
log.Panicf("Only %d-byte IVs are supported", ivLen)
}
if len(in) == 0 {
log.Panic("Zero-length input data is not supported")
}
if len(g.key) != keyLen {
log.Panicf("Wrong key length: %d. Key has been wiped?", len(g.key))
}
// If the "dst" slice is large enough we can use it as our output buffer
outLen := len(in) + tagLen
var buf []byte
inplace := false
if cap(dst)-len(dst) >= outLen {
inplace = true
buf = dst[len(dst) : len(dst)+outLen]
} else {
buf = make([]byte, outLen)
}
C.aead_seal(C.aeadTypeGcm,
(*C.uchar)(&in[0]),
C.int(len(in)),
(*C.uchar)(&authData[0]),
C.int(len(authData)),
(*C.uchar)(&g.key[0]),
C.int(len(g.key)),
(*C.uchar)(&iv[0]),
C.int(len(iv)),
(*C.uchar)(&buf[0]),
C.int(len(buf)))
if inplace {
return dst[:len(dst)+outLen]
}
return append(dst, buf...)
}
// Open decrypts "in" using "iv" and "authData" and append the result to "dst"
func (g *StupidGCM) Open(dst, iv, in, authData []byte) ([]byte, error) {
if len(iv) != ivLen {
log.Panicf("Only %d-byte IVs are supported", ivLen)
}
if len(g.key) != keyLen {
log.Panicf("Wrong key length: %d. Key has been wiped?", len(g.key))
}
if len(in) <= tagLen {
return nil, fmt.Errorf("stupidgcm: input data too short (%d bytes)", len(in))
}
// If the "dst" slice is large enough we can use it as our output buffer
outLen := len(in) - tagLen
var buf []byte
inplace := false
if cap(dst)-len(dst) >= outLen {
inplace = true
buf = dst[len(dst) : len(dst)+outLen]
} else {
buf = make([]byte, len(in)-tagLen)
}
ciphertext := in[:len(in)-tagLen]
tag := in[len(in)-tagLen:]
// https://wiki.openssl.org/index.php/EVP_Authenticated_Encryption_and_Decryption#Authenticated_Encryption_using_GCM_mode
// Create scratch space "context"
ctx := C.EVP_CIPHER_CTX_new()
if ctx == nil {
log.Panic("EVP_CIPHER_CTX_new failed")
}
// Set cipher to AES-256
if C.EVP_DecryptInit_ex(ctx, C.EVP_aes_256_gcm(), nil, nil, nil) != 1 {
log.Panic("EVP_DecryptInit_ex I failed")
}
// Use 16-byte IV
if C.EVP_CIPHER_CTX_ctrl(ctx, C.EVP_CTRL_GCM_SET_IVLEN, ivLen, nil) != 1 {
log.Panic("EVP_CIPHER_CTX_ctrl EVP_CTRL_GCM_SET_IVLEN failed")
}
// Set key and IV
if C.EVP_DecryptInit_ex(ctx, nil, nil, (*C.uchar)(&g.key[0]), (*C.uchar)(&iv[0])) != 1 {
log.Panic("EVP_DecryptInit_ex II failed")
}
// Set expected GMAC tag
if C.EVP_CIPHER_CTX_ctrl(ctx, C.EVP_CTRL_GCM_SET_TAG, tagLen, (unsafe.Pointer)(&tag[0])) != 1 {
log.Panic("EVP_CIPHER_CTX_ctrl failed")
}
// Provide authentication data
var resultLen C.int
if C.EVP_DecryptUpdate(ctx, nil, &resultLen, (*C.uchar)(&authData[0]), C.int(len(authData))) != 1 {
log.Panic("EVP_DecryptUpdate authData failed")
}
if int(resultLen) != len(authData) {
log.Panicf("Unexpected length %d", resultLen)
}
// Decrypt "ciphertext" into "buf"
if C.EVP_DecryptUpdate(ctx, (*C.uchar)(&buf[0]), &resultLen, (*C.uchar)(&ciphertext[0]), C.int(len(ciphertext))) != 1 {
log.Panic("EVP_DecryptUpdate failed")
}
if int(resultLen) != len(ciphertext) {
log.Panicf("Unexpected length %d", resultLen)
}
// Check GMAC
dummy := make([]byte, 16)
res := C.EVP_DecryptFinal_ex(ctx, (*C.uchar)(&dummy[0]), &resultLen)
if resultLen != 0 {
log.Panicf("Unexpected length %d", resultLen)
}
// Free scratch space
C.EVP_CIPHER_CTX_free(ctx)
if res != 1 {
// The error code must always be checked by the calling function, because the decrypted buffer
// may contain corrupted data that we are returning in case the user forced reads
if g.forceDecode {
return append(dst, buf...), ErrAuth
}
return nil, ErrAuth
}
if inplace {
return dst[:len(dst)+outLen], nil
}
return append(dst, buf...), nil
}
// Wipe tries to wipe the AES key from memory by overwriting it with zeros
// and setting the reference to nil.
//
// This is not bulletproof due to possible GC copies, but
// still raises the bar for extracting the key.
func (g *StupidGCM) Wipe() {
for i := range g.key {
g.key[i] = 0
}
g.key = nil
}

@ -17,6 +17,8 @@ import (
)
type stupidXchacha20poly1305 struct {
// array instead of byte slice like
// `struct xchacha20poly1305` in x/crypto/chacha20poly1305
key [chacha20poly1305.KeySize]byte
wiped bool
}
@ -41,7 +43,7 @@ func (*stupidXchacha20poly1305) NonceSize() int {
}
func (*stupidXchacha20poly1305) Overhead() int {
return 16
return tagLen
}
func (x *stupidXchacha20poly1305) Seal(dst, nonce, plaintext, additionalData []byte) []byte {
@ -61,9 +63,8 @@ func (x *stupidXchacha20poly1305) Seal(dst, nonce, plaintext, additionalData []b
panic("plaintext too large")
}
c := new(stupidChacha20poly1305)
hKey, _ := chacha20.HChaCha20(x.key[:], nonce[0:16])
copy(c.key[:], hKey)
c := newChacha20poly1305(hKey)
defer c.Wipe()
// The first 4 bytes of the final nonce are unused counter space.
@ -87,9 +88,8 @@ func (x *stupidXchacha20poly1305) Open(dst, nonce, ciphertext, additionalData []
panic("ciphertext too large")
}
c := new(stupidChacha20poly1305)
hKey, _ := chacha20.HChaCha20(x.key[:], nonce[0:16])
copy(c.key[:], hKey)
c := newChacha20poly1305(hKey)
defer c.Wipe()
// The first 4 bytes of the final nonce are unused counter space.
Loading…
Cancel
Save