aboutsummaryrefslogtreecommitdiff
path: root/internal/stupidgcm/xchacha.go
blob: 055b7f7bc97ed60661a716ba6415fb59e4e484ac (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
// +build !without_openssl

// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
//
// Copied from
// https://github.com/golang/crypto/blob/32db794688a5a24a23a43f2a984cecd5b3d8da58/chacha20poly1305/xchacha20poly1305.go
// and adapted for stupidgcm by @rfjakob.

package stupidgcm

import (
	"crypto/cipher"
	"errors"
	"log"

	"golang.org/x/crypto/chacha20"
	"golang.org/x/crypto/chacha20poly1305"
)

type stupidXchacha20poly1305 struct {
	// array instead of byte slice like
	// `struct xchacha20poly1305` in x/crypto/chacha20poly1305
	key   [chacha20poly1305.KeySize]byte
	wiped bool
}

// NewXchacha20poly1305 returns a XChaCha20-Poly1305 AEAD that uses the given 256-bit key.
//
// XChaCha20-Poly1305 is a ChaCha20-Poly1305 variant that takes a longer nonce,
// suitable to be generated randomly without risk of collisions. It should be
// preferred when nonce uniqueness cannot be trivially ensured, or whenever
// nonces are randomly generated.
func NewXchacha20poly1305(key []byte) cipher.AEAD {
	if len(key) != chacha20poly1305.KeySize {
		log.Panic("bad key length")
	}
	ret := new(stupidXchacha20poly1305)
	copy(ret.key[:], key)
	return ret
}

func (*stupidXchacha20poly1305) NonceSize() int {
	return chacha20poly1305.NonceSizeX
}

func (*stupidXchacha20poly1305) Overhead() int {
	return tagLen
}

func (x *stupidXchacha20poly1305) Seal(dst, nonce, plaintext, additionalData []byte) []byte {
	if x.wiped {
		log.Panic("BUG: tried to use wiped key")
	}
	if len(nonce) != chacha20poly1305.NonceSizeX {
		log.Panic("bad nonce length passed to Seal")
	}

	// XChaCha20-Poly1305 technically supports a 64-bit counter, so there is no
	// size limit. However, since we reuse the ChaCha20-Poly1305 implementation,
	// the second half of the counter is not available. This is unlikely to be
	// an issue because the cipher.AEAD API requires the entire message to be in
	// memory, and the counter overflows at 256 GB.
	if uint64(len(plaintext)) > (1<<38)-64 {
		log.Panic("plaintext too large")
	}

	hKey, _ := chacha20.HChaCha20(x.key[:], nonce[0:16])
	c := NewChacha20poly1305(hKey)
	defer c.Wipe()

	// The first 4 bytes of the final nonce are unused counter space.
	cNonce := make([]byte, chacha20poly1305.NonceSize)
	copy(cNonce[4:12], nonce[16:24])

	return c.Seal(dst, cNonce[:], plaintext, additionalData)
}

func (x *stupidXchacha20poly1305) Open(dst, nonce, ciphertext, additionalData []byte) ([]byte, error) {
	if x.wiped {
		log.Panic("BUG: tried to use wiped key")
	}
	if len(nonce) != chacha20poly1305.NonceSizeX {
		log.Panic("bad nonce length passed to Open")
	}
	if len(ciphertext) < 16 {
		return nil, errors.New("message too short")
	}
	if uint64(len(ciphertext)) > (1<<38)-48 {
		log.Panic("ciphertext too large")
	}

	hKey, _ := chacha20.HChaCha20(x.key[:], nonce[0:16])
	c := NewChacha20poly1305(hKey)
	defer c.Wipe()

	// The first 4 bytes of the final nonce are unused counter space.
	cNonce := make([]byte, chacha20poly1305.NonceSize)
	copy(cNonce[4:12], nonce[16:24])

	return c.Open(dst, cNonce[:], ciphertext, additionalData)
}

// 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 *stupidXchacha20poly1305) Wipe() {
	g.wiped = true
	for i := range g.key {
		g.key[i] = 0
	}
}