1. Des produits
  2.   E-mail
  3.   GO
  4.   go-message

go-message

 
 

Bibliothèque Go open source pour les e‑mail & le format de message Internet

Analysez, générez & gérez les en‑têtes RFC 5322, MIME, et Content-Disposition via l’API Go en streaming.

Qu'est-ce que go-message ?

go-message est une bibliothèque Go haute performance et en flux, conçue pour analyser et générer des messages électroniques conformes au format de message Internet (RFC 5322), aux extensions MIME (RFC 2045–2047) et aux en‑têtes Content‑Disposition (RFC 2183). Elle permet aux développeurs Go de traiter le contenu des e‑mails efficacement sans charger l’ensemble des messages en mémoire, ce qui la rend idéale pour les serveurs et clients de messagerie évolutifs. La bibliothèque prend en charge le décodage automatique des jeux de caractères et s’intègre parfaitement à la bibliothèque standard de Go.

Conçue avec modularité et extensibilité à l’esprit, go-message comprend des sous‑packages dédiés tels que `mail` pour la gestion de courrier de haut niveau et `textproto` pour l’analyse de protocole bas‑niveau. Son architecture adaptée à DKIM garantit la compatibilité avec les flux de travail modernes d’authentification des e‑mails. Grâce à ses capacités de diffusion en continu intégrées et à la normalisation des jeux de caractères, go-message simplifie les tâches complexes de traitement des e‑mails telles que l’analyse des corps multipart, le décodage des en‑têtes encodés et la gestion des structures MIME imbriquées — tout en conservant l’efficacité mémoire et les performances.

Previous Next

Premiers pas avec go-message

Pour commencer à utiliser go-message, installez-le via `go get` depuis le dépôt officiel [go-message GitHub](https://github.com/emersion/go-message). L'approche recommandée consiste à utiliser les modules Go : exécutez `go get github.com/emersion/go-message` dans le répertoire de votre projet. Pour le support du décodage des jeux de caractères, incluez `import _ "github.com/emersion/go-message/charset"` afin d'activer tous les encodages standards. La bibliothèque est légère, sans dépendances, et s'intègre parfaitement aux applications Go existantes.

Installer go-message via les modules Go

go get github.com/emersion/go-message
# Optional: enable full charset support
import _ "github.com/emersion/go-message/charset"

Analyse d'e-mails en streaming

go-message fournit un analyseur en flux qui traite les messages électroniques de manière incrémentielle sans charger l'intégralité du contenu en mémoire. Cela est particulièrement bénéfique pour la gestion de gros courriels ou d'un traitement de courrier à haut volume. L'analyseur lit les en-têtes et les parties du corps séquentiellement, permettant aux développeurs d'inspecter ou de transférer les messages en temps réel. Il prend en charge à la fois les messages conformes aux RFC et les messages malformés avec grâce, ce qui le rend adapté aux serveurs de messagerie de production. En tirant parti du `io.Reader` de Go, la bibliothèque s'intègre naturellement aux opérations d'E/S réseau et fichier.

Comment analyser un message e-mail via l'API de streaming ?

import (
	"bytes"
	"github.com/emersion/go-message"
)

func parseEmail(data []byte) error {
	r := bytes.NewReader(data)
	m, err := message.Read(r)
	if err != nil {
		return err
	}
	// Access headers and body parts
	return nil
}

Gestion des parties MIME

go-message prend en charge entièrement l'analyse et la génération de messages MIME multipart tels que définis dans les RFC 2045 et RFC 2046. Les développeurs peuvent naviguer dans des structures multipart complexes—y compris les parties imbriquées—en utilisant des API intuitives. La bibliothèque décode automatiquement les encodages de transfert (par ex., base64, quoted-printable) et fournit l'accès aux parties individuelles via l'interface `Part`. Cela permet une composition d'e-mails robuste et l'extraction des pièces jointes, des alternatives HTML/texte et des ressources intégrées. Sa nature en flux garantit une gestion efficace même pour les gros messages multipart contenant de nombreuses parties.

Comment extraire les parties multiparties d'un e‑mail ?

import (
	"github.com/emersion/go-message"
	"github.com/emersion/go-message/textproto"
)

func extractParts(m *message.Message) error {
	if m.Multipart() {
		for _, p := range m.Parts() {
			// Process each part (e.g., text, attachment)
			mediaType, params, _ := p.Header.MediaType()
			if mediaType == "text/plain" {
				// Read plain text content
				content, _ := io.ReadAll(p.Body)
			}
		}
	}
	return nil
}

Prise en charge des jeux de caractères et de l'encodage

go-message inclut une gestion robuste et automatique des jeux de caractères et du codage pour les en-têtes et le corps des e‑mails. Il prend en charge le décodage des en‑têtes encodés selon la RFC 2047 (par ex., `=?utf-8?B?...?=`) et le texte du corps dans divers jeux de caractères (UTF‑8, ISO‑8859, etc.). En important le package optionnel `github.com/emersion/go-message/charset`, les développeurs obtiennent l’accès à tous les jeux de caractères IANA enregistrés via `golang.org/x/text/encoding`. Cela garantit un rendu précis du contenu e‑mail international, y compris les scripts non latins et les symboles spéciaux, sans détection ou conversion manuelle des jeux de caractères.

Comment décoder un en‑tête encodé en jeu de caractères ?

import (
	"github.com/emersion/go-message"
	_ "github.com/emersion/go-message/charset" // Enable all charsets
)

func decodeSubject(m *message.Message) (string, error) {
	subject, err := m.Header.Get("Subject")
	if err != nil {
		return "", err
	}
	// Automatically decoded using registered charsets
	return subject, nil
}

Signature de messages compatible DKIM

go-message est conçu pour être compatible DKIM, permettant une intégration fluide avec les flux de travail de signature et de vérification cryptographiques. Son analyseur en flux préserve l’intégrité de la structure du message, permettant aux signataires de signer uniquement le corps canonisé et les en‑têtes sélectionnés sans ré‑encodage. La bibliothèque évite les transformations inutiles (par ex., la normalisation des fins de ligne) qui pourraient casser les signatures DKIM. Les développeurs peuvent créer des pipelines de signature d’e‑mail en combinant go-message avec des bibliothèques comme `github.com/emersion/go-dkim`, assurant la conformité à la RFC 6376 pour l’authentification des messages basée sur le domaine.

Comment préparer un message pour la signature DKIM ?

import (
	"bytes"
	"github.com/emersion/go-message"
	"github.com/emersion/go-message/textproto"
)

func prepareForDKIM(m *message.Message) (*bytes.Buffer, error) {
	var buf bytes.Buffer
	// Write canonicalized headers and body
	h := m.Header
	h.WriteTo(&buf)
	buf.WriteString("\r\n")
	if _, err := io.Copy(&buf, m.Body); err != nil {
		return nil, err
	}
	return &buf, nil
}
 Français