github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/logs/def.go

// Ce package définit les paramètres de connexion
// nécessaire aux différents services (mail, serveur, base de données, etc)
package logs

import (
	"crypto/aes"
	"crypto/cipher"
	"crypto/md5"
	"crypto/rand"
	"encoding/hex"
	"errors"
	"fmt"
	"io"
	"log"
	mrd "math/rand"
	"net/smtp"
	"strconv"
	"strings"
)

var debugEmails = [4]string{
	"x.ben.x@free.fr", "bench26@gmail.com", "benoit.kugler@ens-lyon.fr", "benoit.kugler@inria.fr",
}

// SMTP enregistre les informations de connection
type SMTP struct {
	Host, Password string

	// Should be a valid adress mail
	User string
	Port int

	// Adresse à laquelle répondre
	ReplyTo string

	// Si false, envoie tous les mails sur une même adresse.
	Prod bool
}

func (creds SMTP) GetFromAuth() (string, smtp.Auth) {
	from := fmt.Sprintf("%s:%d", creds.Host, creds.Port)
	auth := smtp.PlainAuth("", creds.User, creds.Password, creds.Host)
	return from, auth
}

func (creds SMTP) GetTo(to string) string {
	if !creds.Prod { // sécurité
		oldTo := to
		to = debugEmails[mrd.Intn(4)]
		log.Printf("Dev mode : changement de destinataire : %s ---> %s", oldTo, to)
	}
	return strings.TrimSpace(to)
}

type DB struct {
	Host, Name, User, Password string
	Port                       int
}

type Joomeo struct {
	Apikey, Login, Password string
}

type CredencesHelloAsso struct {
	Id  string
	Key string
}

type offuscateur struct {
	m, a, b int64 // m * b > a
}

func (o offuscateur) crypte(id int64) int64 {
	return (id+o.b)*o.m - o.a
}

func (o offuscateur) parse(entry int) (id int64, ok bool) {
	a := int64(entry) + o.a
	if a%o.m != 0 {
		return 0, false
	}
	return a/o.m - o.b, true
}

type OffuscLabelVirement struct {
	offuscateur
}

func (o OffuscLabelVirement) Offusc(id int64) string {
	return fmt.Sprintf("ACVE: %d", o.crypte(id))
}

func (o OffuscLabelVirement) Parse(entry int) (id int64, err error) {
	out, ok := o.parse(entry)
	if !ok {
		return 0, fmt.Errorf("label de virement invalide : %d", entry)
	}
	return out, nil
}

type OffuscIdVote struct {
	offuscateur
}

func (o OffuscIdVote) Offusc(id int64) string {
	return fmt.Sprintf("%d", o.crypte(id))
}

func (o OffuscIdVote) Parse(entryS string) (id int64, err error) {
	entry, err := strconv.Atoi(entryS)
	if err != nil {
		return 0, fmt.Errorf("lien de vote non décodable : %s", err)
	}
	out, ok := o.parse(entry)
	if !ok {
		return 0, fmt.Errorf("lien de vote invalide : %d", entry)
	}
	return out, nil
}

type OffuscIdDirecteur struct {
	offuscateur
}

// Password renvoie un mot de passe constant en fonction de 'id'
func (o OffuscIdDirecteur) Password(id int64) string {
	lenWord, L := 4, len(offuscPasswordDir)
	index := int(uint(id)) % L
	if index > L-lenWord {
		index -= lenWord
	}

	nb := o.crypte(id)
	return offuscPasswordDir[index:index+lenWord] + fmt.Sprintf("%d", nb)
}

type Encrypteur []byte

func NewEncrypteur(key string) Encrypteur {
	hasher := md5.New()
	if _, err := hasher.Write([]byte(key)); err != nil {
		log.Fatal(err)
	}
	return []byte(hex.EncodeToString(hasher.Sum(nil)))
}

func (pass Encrypteur) Encrypt(data []byte) ([]byte, error) {
	block, _ := aes.NewCipher(pass)
	gcm, err := cipher.NewGCM(block)
	if err != nil {
		return nil, err
	}
	nonce := make([]byte, gcm.NonceSize())
	if _, err = io.ReadFull(rand.Reader, nonce); err != nil {
		return nil, err
	}
	ciphertext := gcm.Seal(nonce, nonce, data, nil)
	return ciphertext, nil
}

func (pass Encrypteur) Decrypt(data []byte) ([]byte, error) {
	block, err := aes.NewCipher(pass)
	if err != nil {
		return nil, err
	}
	gcm, err := cipher.NewGCM(block)
	if err != nil {
		return nil, err
	}
	nonceSize := gcm.NonceSize()
	if len(data) <= nonceSize {
		return nil, errors.New("data too short")
	}
	nonce, ciphertext := data[:nonceSize], data[nonceSize:]
	plaintext, err := gcm.Open(nil, nonce, ciphertext, nil)
	return plaintext, err
}