986f076276
Add a new generic container registry client via a new `container` package. Use this to create a command line utility as well as a new upload target for container registries. The code uses the github.com/containers/* project and packages to interact with container registires that is also used by skopeo, podman et al. One if the dependencies is `proglottis/gpgme` that is using cgo to bind libgpgme, so we have to add the corresponding devel package to the BuildRequires as well as installing it on CI. Checks will follow later via an integration test.
399 lines
10 KiB
Go
399 lines
10 KiB
Go
package pkcs7
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/aes"
|
|
"crypto/cipher"
|
|
"crypto/des"
|
|
"crypto/rand"
|
|
"crypto/rsa"
|
|
"crypto/x509"
|
|
"crypto/x509/pkix"
|
|
"encoding/asn1"
|
|
"errors"
|
|
"fmt"
|
|
)
|
|
|
|
type envelopedData struct {
|
|
Version int
|
|
RecipientInfos []recipientInfo `asn1:"set"`
|
|
EncryptedContentInfo encryptedContentInfo
|
|
}
|
|
|
|
type encryptedData struct {
|
|
Version int
|
|
EncryptedContentInfo encryptedContentInfo
|
|
}
|
|
|
|
type recipientInfo struct {
|
|
Version int
|
|
IssuerAndSerialNumber issuerAndSerial
|
|
KeyEncryptionAlgorithm pkix.AlgorithmIdentifier
|
|
EncryptedKey []byte
|
|
}
|
|
|
|
type encryptedContentInfo struct {
|
|
ContentType asn1.ObjectIdentifier
|
|
ContentEncryptionAlgorithm pkix.AlgorithmIdentifier
|
|
EncryptedContent asn1.RawValue `asn1:"tag:0,optional,explicit"`
|
|
}
|
|
|
|
const (
|
|
// EncryptionAlgorithmDESCBC is the DES CBC encryption algorithm
|
|
EncryptionAlgorithmDESCBC = iota
|
|
|
|
// EncryptionAlgorithmAES128CBC is the AES 128 bits with CBC encryption algorithm
|
|
// Avoid this algorithm unless required for interoperability; use AES GCM instead.
|
|
EncryptionAlgorithmAES128CBC
|
|
|
|
// EncryptionAlgorithmAES256CBC is the AES 256 bits with CBC encryption algorithm
|
|
// Avoid this algorithm unless required for interoperability; use AES GCM instead.
|
|
EncryptionAlgorithmAES256CBC
|
|
|
|
// EncryptionAlgorithmAES128GCM is the AES 128 bits with GCM encryption algorithm
|
|
EncryptionAlgorithmAES128GCM
|
|
|
|
// EncryptionAlgorithmAES256GCM is the AES 256 bits with GCM encryption algorithm
|
|
EncryptionAlgorithmAES256GCM
|
|
)
|
|
|
|
// ContentEncryptionAlgorithm determines the algorithm used to encrypt the
|
|
// plaintext message. Change the value of this variable to change which
|
|
// algorithm is used in the Encrypt() function.
|
|
var ContentEncryptionAlgorithm = EncryptionAlgorithmDESCBC
|
|
|
|
// ErrUnsupportedEncryptionAlgorithm is returned when attempting to encrypt
|
|
// content with an unsupported algorithm.
|
|
var ErrUnsupportedEncryptionAlgorithm = errors.New("pkcs7: cannot encrypt content: only DES-CBC, AES-CBC, and AES-GCM supported")
|
|
|
|
// ErrPSKNotProvided is returned when attempting to encrypt
|
|
// using a PSK without actually providing the PSK.
|
|
var ErrPSKNotProvided = errors.New("pkcs7: cannot encrypt content: PSK not provided")
|
|
|
|
const nonceSize = 12
|
|
|
|
type aesGCMParameters struct {
|
|
Nonce []byte `asn1:"tag:4"`
|
|
ICVLen int
|
|
}
|
|
|
|
func encryptAESGCM(content []byte, key []byte) ([]byte, *encryptedContentInfo, error) {
|
|
var keyLen int
|
|
var algID asn1.ObjectIdentifier
|
|
switch ContentEncryptionAlgorithm {
|
|
case EncryptionAlgorithmAES128GCM:
|
|
keyLen = 16
|
|
algID = OIDEncryptionAlgorithmAES128GCM
|
|
case EncryptionAlgorithmAES256GCM:
|
|
keyLen = 32
|
|
algID = OIDEncryptionAlgorithmAES256GCM
|
|
default:
|
|
return nil, nil, fmt.Errorf("invalid ContentEncryptionAlgorithm in encryptAESGCM: %d", ContentEncryptionAlgorithm)
|
|
}
|
|
if key == nil {
|
|
// Create AES key
|
|
key = make([]byte, keyLen)
|
|
|
|
_, err := rand.Read(key)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
}
|
|
|
|
// Create nonce
|
|
nonce := make([]byte, nonceSize)
|
|
|
|
_, err := rand.Read(nonce)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
// Encrypt content
|
|
block, err := aes.NewCipher(key)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
gcm, err := cipher.NewGCM(block)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
ciphertext := gcm.Seal(nil, nonce, content, nil)
|
|
|
|
// Prepare ASN.1 Encrypted Content Info
|
|
paramSeq := aesGCMParameters{
|
|
Nonce: nonce,
|
|
ICVLen: gcm.Overhead(),
|
|
}
|
|
|
|
paramBytes, err := asn1.Marshal(paramSeq)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
eci := encryptedContentInfo{
|
|
ContentType: OIDData,
|
|
ContentEncryptionAlgorithm: pkix.AlgorithmIdentifier{
|
|
Algorithm: algID,
|
|
Parameters: asn1.RawValue{
|
|
Tag: asn1.TagSequence,
|
|
Bytes: paramBytes,
|
|
},
|
|
},
|
|
EncryptedContent: marshalEncryptedContent(ciphertext),
|
|
}
|
|
|
|
return key, &eci, nil
|
|
}
|
|
|
|
func encryptDESCBC(content []byte, key []byte) ([]byte, *encryptedContentInfo, error) {
|
|
if key == nil {
|
|
// Create DES key
|
|
key = make([]byte, 8)
|
|
|
|
_, err := rand.Read(key)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
}
|
|
|
|
// Create CBC IV
|
|
iv := make([]byte, des.BlockSize)
|
|
_, err := rand.Read(iv)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
// Encrypt padded content
|
|
block, err := des.NewCipher(key)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
mode := cipher.NewCBCEncrypter(block, iv)
|
|
plaintext, err := pad(content, mode.BlockSize())
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
cyphertext := make([]byte, len(plaintext))
|
|
mode.CryptBlocks(cyphertext, plaintext)
|
|
|
|
// Prepare ASN.1 Encrypted Content Info
|
|
eci := encryptedContentInfo{
|
|
ContentType: OIDData,
|
|
ContentEncryptionAlgorithm: pkix.AlgorithmIdentifier{
|
|
Algorithm: OIDEncryptionAlgorithmDESCBC,
|
|
Parameters: asn1.RawValue{Tag: 4, Bytes: iv},
|
|
},
|
|
EncryptedContent: marshalEncryptedContent(cyphertext),
|
|
}
|
|
|
|
return key, &eci, nil
|
|
}
|
|
|
|
func encryptAESCBC(content []byte, key []byte) ([]byte, *encryptedContentInfo, error) {
|
|
var keyLen int
|
|
var algID asn1.ObjectIdentifier
|
|
switch ContentEncryptionAlgorithm {
|
|
case EncryptionAlgorithmAES128CBC:
|
|
keyLen = 16
|
|
algID = OIDEncryptionAlgorithmAES128CBC
|
|
case EncryptionAlgorithmAES256CBC:
|
|
keyLen = 32
|
|
algID = OIDEncryptionAlgorithmAES256CBC
|
|
default:
|
|
return nil, nil, fmt.Errorf("invalid ContentEncryptionAlgorithm in encryptAESCBC: %d", ContentEncryptionAlgorithm)
|
|
}
|
|
|
|
if key == nil {
|
|
// Create AES key
|
|
key = make([]byte, keyLen)
|
|
|
|
_, err := rand.Read(key)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
}
|
|
|
|
// Create CBC IV
|
|
iv := make([]byte, aes.BlockSize)
|
|
_, err := rand.Read(iv)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
// Encrypt padded content
|
|
block, err := aes.NewCipher(key)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
mode := cipher.NewCBCEncrypter(block, iv)
|
|
plaintext, err := pad(content, mode.BlockSize())
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
cyphertext := make([]byte, len(plaintext))
|
|
mode.CryptBlocks(cyphertext, plaintext)
|
|
|
|
// Prepare ASN.1 Encrypted Content Info
|
|
eci := encryptedContentInfo{
|
|
ContentType: OIDData,
|
|
ContentEncryptionAlgorithm: pkix.AlgorithmIdentifier{
|
|
Algorithm: algID,
|
|
Parameters: asn1.RawValue{Tag: 4, Bytes: iv},
|
|
},
|
|
EncryptedContent: marshalEncryptedContent(cyphertext),
|
|
}
|
|
|
|
return key, &eci, nil
|
|
}
|
|
|
|
// Encrypt creates and returns an envelope data PKCS7 structure with encrypted
|
|
// recipient keys for each recipient public key.
|
|
//
|
|
// The algorithm used to perform encryption is determined by the current value
|
|
// of the global ContentEncryptionAlgorithm package variable. By default, the
|
|
// value is EncryptionAlgorithmDESCBC. To use a different algorithm, change the
|
|
// value before calling Encrypt(). For example:
|
|
//
|
|
// ContentEncryptionAlgorithm = EncryptionAlgorithmAES128GCM
|
|
//
|
|
// TODO(fullsailor): Add support for encrypting content with other algorithms
|
|
func Encrypt(content []byte, recipients []*x509.Certificate) ([]byte, error) {
|
|
var eci *encryptedContentInfo
|
|
var key []byte
|
|
var err error
|
|
|
|
// Apply chosen symmetric encryption method
|
|
switch ContentEncryptionAlgorithm {
|
|
case EncryptionAlgorithmDESCBC:
|
|
key, eci, err = encryptDESCBC(content, nil)
|
|
case EncryptionAlgorithmAES128CBC:
|
|
fallthrough
|
|
case EncryptionAlgorithmAES256CBC:
|
|
key, eci, err = encryptAESCBC(content, nil)
|
|
case EncryptionAlgorithmAES128GCM:
|
|
fallthrough
|
|
case EncryptionAlgorithmAES256GCM:
|
|
key, eci, err = encryptAESGCM(content, nil)
|
|
|
|
default:
|
|
return nil, ErrUnsupportedEncryptionAlgorithm
|
|
}
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Prepare each recipient's encrypted cipher key
|
|
recipientInfos := make([]recipientInfo, len(recipients))
|
|
for i, recipient := range recipients {
|
|
encrypted, err := encryptKey(key, recipient)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
ias, err := cert2issuerAndSerial(recipient)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
info := recipientInfo{
|
|
Version: 0,
|
|
IssuerAndSerialNumber: ias,
|
|
KeyEncryptionAlgorithm: pkix.AlgorithmIdentifier{
|
|
Algorithm: OIDEncryptionAlgorithmRSA,
|
|
},
|
|
EncryptedKey: encrypted,
|
|
}
|
|
recipientInfos[i] = info
|
|
}
|
|
|
|
// Prepare envelope content
|
|
envelope := envelopedData{
|
|
EncryptedContentInfo: *eci,
|
|
Version: 0,
|
|
RecipientInfos: recipientInfos,
|
|
}
|
|
innerContent, err := asn1.Marshal(envelope)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Prepare outer payload structure
|
|
wrapper := contentInfo{
|
|
ContentType: OIDEnvelopedData,
|
|
Content: asn1.RawValue{Class: 2, Tag: 0, IsCompound: true, Bytes: innerContent},
|
|
}
|
|
|
|
return asn1.Marshal(wrapper)
|
|
}
|
|
|
|
// EncryptUsingPSK creates and returns an encrypted data PKCS7 structure,
|
|
// encrypted using caller provided pre-shared secret.
|
|
func EncryptUsingPSK(content []byte, key []byte) ([]byte, error) {
|
|
var eci *encryptedContentInfo
|
|
var err error
|
|
|
|
if key == nil {
|
|
return nil, ErrPSKNotProvided
|
|
}
|
|
|
|
// Apply chosen symmetric encryption method
|
|
switch ContentEncryptionAlgorithm {
|
|
case EncryptionAlgorithmDESCBC:
|
|
_, eci, err = encryptDESCBC(content, key)
|
|
|
|
case EncryptionAlgorithmAES128GCM:
|
|
fallthrough
|
|
case EncryptionAlgorithmAES256GCM:
|
|
_, eci, err = encryptAESGCM(content, key)
|
|
|
|
default:
|
|
return nil, ErrUnsupportedEncryptionAlgorithm
|
|
}
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Prepare encrypted-data content
|
|
ed := encryptedData{
|
|
Version: 0,
|
|
EncryptedContentInfo: *eci,
|
|
}
|
|
innerContent, err := asn1.Marshal(ed)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Prepare outer payload structure
|
|
wrapper := contentInfo{
|
|
ContentType: OIDEncryptedData,
|
|
Content: asn1.RawValue{Class: 2, Tag: 0, IsCompound: true, Bytes: innerContent},
|
|
}
|
|
|
|
return asn1.Marshal(wrapper)
|
|
}
|
|
|
|
func marshalEncryptedContent(content []byte) asn1.RawValue {
|
|
asn1Content, _ := asn1.Marshal(content)
|
|
return asn1.RawValue{Tag: 0, Class: 2, Bytes: asn1Content, IsCompound: true}
|
|
}
|
|
|
|
func encryptKey(key []byte, recipient *x509.Certificate) ([]byte, error) {
|
|
if pub := recipient.PublicKey.(*rsa.PublicKey); pub != nil {
|
|
return rsa.EncryptPKCS1v15(rand.Reader, pub, key)
|
|
}
|
|
return nil, ErrUnsupportedAlgorithm
|
|
}
|
|
|
|
func pad(data []byte, blocklen int) ([]byte, error) {
|
|
if blocklen < 1 {
|
|
return nil, fmt.Errorf("invalid blocklen %d", blocklen)
|
|
}
|
|
padlen := blocklen - (len(data) % blocklen)
|
|
if padlen == 0 {
|
|
padlen = blocklen
|
|
}
|
|
pad := bytes.Repeat([]byte{byte(padlen)}, padlen)
|
|
return append(data, pad...), nil
|
|
}
|