π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
package email
import (
"bytes"
"crypto/rand"
"crypto/tls"
"fmt"
"html/template"
"mime"
"mime/quotedprintable"
"net"
"net/mail"
"net/smtp"
"path"
"slices"
"strings"
"time"
"github.com/ente/museum/ente"
"github.com/ente/stacktrace"
log "github.com/sirupsen/logrus"
"github.com/spf13/viper"
)
var knownInvalidEmailErrors = []string{
"Invalid RCPT TO address provided",
"Invalid domain name",
}
func NormalizeEmail(email string) string {
return strings.ToLower(strings.TrimSpace(email))
}
// https://datatracker.ietf.org/doc/html/rfc5322#section-2.1.1
const base64LineLength = 900 // standard MIME line length for base64 content
func sanitizeHeaderValue(s string) string {
if s == "" {
return s
}
var b strings.Builder
b.Grow(len(s))
for _, r := range s {
if r == '\r' || r == '\n' {
continue
}
if r < 0x20 && r != '\t' {
continue
}
b.WriteRune(r)
}
return strings.TrimSpace(b.String())
}
func containsCRLF(s string) bool {
return strings.ContainsRune(s, '\r') || strings.ContainsRune(s, '\n')
}
func wrapToMaxLineLength(s string, maxLen int) string {
if maxLen <= 0 {
return s
}
clean := strings.ReplaceAll(strings.ReplaceAll(s, "\r", ""), "\n", "")
if len(clean) <= maxLen {
return clean
}
var b strings.Builder
b.Grow(len(clean) + len(clean)/maxLen)
for i := 0; i < len(clean); i += maxLen {
end := min(i+maxLen, len(clean))
b.WriteString(clean[i:end])
if end < len(clean) {
b.WriteByte('\n')
}
}
return b.String()
}
func buildHTMLMIMEPart(htmlBody string) (string, error) {
var encodedBody bytes.Buffer
writer := quotedprintable.NewWriter(&encodedBody)
if _, err := writer.Write([]byte(htmlBody)); err != nil {
return "", err
}
if err := writer.Close(); err != nil {
return "", err
}
return "Content-Type: text/html; charset=utf-8\n" +
"Content-Transfer-Encoding: quoted-printable\n\n" +
encodedBody.String() + "\n", nil
}
func Send(toEmails []string, fromName string, fromEmail string, subject string, htmlBody string, inlineImages []map[string]interface{}) error {
if len(toEmails) == 0 {
return ente.ErrBadRequest
}
if viper.GetString("smtp.host") == "" {
log.Infof("Skipping sending email to %s: %s", toEmails[0], subject)
return nil
}
return sendViaSMTP(toEmails, fromName, fromEmail, subject, htmlBody, inlineImages)
}
func sendViaSMTP(toEmails []string, fromName string, fromEmail string, subject string, htmlBody string, inlineImages []map[string]interface{}) error {
smtpServer := viper.GetString("smtp.host")
smtpPort := viper.GetString("smtp.port")
smtpUsername := viper.GetString("smtp.username")
smtpPassword := viper.GetString("smtp.password")
smtpEmail := viper.GetString("smtp.email")
smtpSenderName := viper.GetString("smtp.sender-name")
smtpEncryption := viper.GetString("smtp.encryption")
var emailMessage string
var auth smtp.Auth = nil
if smtpUsername != "" && smtpPassword != "" {
auth = smtp.PlainAuth("", smtpUsername, smtpPassword, smtpServer)
}
if smtpEmail != "" {
fromEmail = smtpEmail
}
if smtpSenderName != "" {
fromName = smtpSenderName
}
if containsCRLF(fromEmail) {
return stacktrace.Propagate(ente.ErrBadRequest, "invalid from email")
}
if slices.ContainsFunc(toEmails, containsCRLF) {
return stacktrace.Propagate(ente.ErrBadRequest, "invalid recipient email")
}
cleanSubject := mime.QEncoding.Encode("utf-8", sanitizeHeaderValue(subject))
var emailAddresses string
for i, addr := range toEmails {
if i != 0 {
emailAddresses += ","
}
emailAddresses += sanitizeHeaderValue(addr)
}
boundary := rand.Text()
header := "Date: " + time.Now().Format(time.RFC1123Z) + "\n" +
"From: " + (&mail.Address{Name: fromName, Address: fromEmail}).String() + "\n" +
"To: " + emailAddresses + "\n" +
"Subject: " + cleanSubject + "\n" +
"MIME-Version: 1.0\n" +
"Content-Type: multipart/related; boundary=" + boundary + "\n\n" +
"--" + boundary + "\n"
htmlContent, err := buildHTMLMIMEPart(htmlBody)
if err != nil {
return stacktrace.Propagate(err, "failed to encode html body")
}
emailMessage = header + htmlContent
if inlineImages == nil {
emailMessage += "--" + boundary + "--"
} else {
for _, inlineImage := range inlineImages {
emailMessage += "--" + boundary + "\n"
var mimeType = sanitizeHeaderValue(inlineImage["mime_type"].(string))
var contentID = sanitizeHeaderValue(inlineImage["cid"].(string))
var imgBase64Str = inlineImage["content"].(string)
var wrappedImgBase64Str = wrapToMaxLineLength(imgBase64Str, base64LineLength)
var image = "Content-Type: " + mimeType + "\n" +
"Content-Transfer-Encoding: base64\n" +
"Content-ID: <" + contentID + ">\n" +
"Content-Disposition: inline\n\n" + wrappedImgBase64Str + "\n"
emailMessage += image
}
emailMessage += "--" + boundary + "--"
}
for _, toEmail := range toEmails {
err := sendMailWithEncryption(smtpServer, smtpPort, auth, fromEmail, []string{toEmail}, []byte(emailMessage), smtpEncryption)
if err != nil {
errMsg := err.Error()
for i := range knownInvalidEmailErrors {
if strings.Contains(errMsg, knownInvalidEmailErrors[i]) {
return stacktrace.Propagate(ente.NewBadRequestWithMessage(fmt.Sprintf("Invalid email %s", toEmail)), "%v", err)
}
}
return stacktrace.Propagate(err, "")
}
}
return nil
}
func sendMailWithEncryption(host, port string, auth smtp.Auth, from string, to []string, msg []byte, encryption string) error {
addr := net.JoinHostPort(host, port)
switch strings.ToLower(encryption) {
case "tls", "ssl":
tlsConfig := &tls.Config{
ServerName: host,
MinVersion: tls.VersionTLS12,
}
conn, err := tls.Dial("tcp", addr, tlsConfig)
if err != nil {
return stacktrace.Propagate(err, "failed to establish TLS connection")
}
defer conn.Close()
client, err := smtp.NewClient(conn, host)
if err != nil {
return stacktrace.Propagate(err, "failed to create SMTP client over TLS")
}
defer client.Close()
return sendWithClient(client, auth, from, to, msg)
default:
return smtp.SendMail(addr, auth, from, to, msg)
}
}
func sendWithClient(client *smtp.Client, auth smtp.Auth, from string, to []string, msg []byte) error {
if auth != nil {
if err := client.Auth(auth); err != nil {
return stacktrace.Propagate(err, "authentication failed")
}
}
if err := client.Mail(from); err != nil {
return stacktrace.Propagate(err, "failed to set sender")
}
for _, addr := range to {
if err := client.Rcpt(addr); err != nil {
return stacktrace.Propagate(err, "failed to add recipient")
}
}
w, err := client.Data()
if err != nil {
return stacktrace.Propagate(err, "failed to create message writer")
}
_, err = w.Write(msg)
if err != nil {
return stacktrace.Propagate(err, "failed to write message")
}
err = w.Close()
if err != nil {
return stacktrace.Propagate(err, "failed to close message writer")
}
err = client.Quit()
return stacktrace.Propagate(err, "")
}
func SendTemplatedEmail(to []string, fromName string, fromEmail string, subject string, templateName string, templateData map[string]interface{}, inlineImages []map[string]interface{}) error {
body, err := getMailBody(templateName, templateData)
if err != nil {
return stacktrace.Propagate(err, "")
}
return Send(to, fromName, fromEmail, subject, body, inlineImages)
}
func SendTemplatedEmailV2(to []string, fromName string, fromEmail string, subject string, baseTemplate, templateName string, templateData map[string]interface{}, inlineImages []map[string]interface{}) error {
body, err := getMailBodyWithBase(baseTemplate, templateName, templateData)
if err != nil {
return stacktrace.Propagate(err, "")
}
return Send(to, fromName, fromEmail, subject, body, inlineImages)
}
func GetMaskedEmail(email string) string {
at := strings.LastIndex(email, "@")
if at >= 0 {
username, domain := email[:at], email[at+1:]
maskedUsername := ""
for i := 0; i < len(username); i++ {
maskedUsername += "*"
}
return maskedUsername + "@" + domain
} else {
return "[invalid_email]"
}
}
func GetMaskedEmailForPublic(email string) string {
email = strings.TrimSpace(email)
at := strings.LastIndex(email, "@")
if at <= 0 || at == len(email)-1 {
return "[invalid_email]"
}
username := email[:at]
domain := email[at+1:]
maskedUsername := maskForPublicUsername(username)
maskedDomain := maskForPublicDomain(domain)
return maskedUsername + "@" + maskedDomain
}
func maskForPublicUsername(s string) string {
runes := []rune(s)
if len(runes) <= 2 {
return s
}
return string(runes[:2]) + strings.Repeat("*", len(runes)-2)
}
func maskForPublicDomain(domain string) string {
runes := []rune(domain)
if len(runes) <= 2 {
return domain
}
return string(runes[0]) + strings.Repeat("*", len(runes)-2) + string(runes[len(runes)-1])
}
func GetMaskedEmailWithHint(email string) string {
email = strings.TrimSpace(email)
at := strings.LastIndex(email, "@")
if at <= 0 || at == len(email)-1 {
return "[invalid_email]"
}
local := email[:at]
domain := email[at+1:]
maskedLocal := maskEmailSegment(local)
if domain == "" {
return maskedLocal + "@[invalid_domain]"
}
domainParts := strings.Split(domain, ".")
if len(domainParts) == 1 {
return fmt.Sprintf("%s@%s", maskedLocal, maskEmailSegment(domainParts[0]))
}
tld := domainParts[len(domainParts)-1]
mainParts := domainParts[:len(domainParts)-1]
for i, part := range mainParts {
mainParts[i] = maskEmailSegment(part)
}
return fmt.Sprintf("%s@%s.%s", maskedLocal, strings.Join(mainParts, "."), tld)
}
func maskEmailSegment(segment string) string {
segment = strings.TrimSpace(segment)
if segment == "" {
return "*"
}
if len(segment) == 1 {
return segment + "*"
}
if len(segment) == 2 {
return segment[:1] + "*"
}
return segment[:1] + strings.Repeat("*", len(segment)-2) + segment[len(segment)-1:]
}
func getMailBody(templateName string, templateData map[string]interface{}) (string, error) {
htmlbody := new(bytes.Buffer)
t, err := template.New(templateName).ParseFiles("mail-templates/" + templateName)
if err != nil {
return "", stacktrace.Propagate(err, "")
}
err = t.Execute(htmlbody, templateData)
if err != nil {
return "", stacktrace.Propagate(err, "")
}
return htmlbody.String(), nil
}
func getMailBodyWithBase(baseTemplateName, templateName string, templateData map[string]interface{}) (string, error) {
htmlBody := new(bytes.Buffer)
baseTemplate := "mail-templates/" + baseTemplateName
specificTemplate := "mail-templates/" + templateName
parts := strings.Split(baseTemplate, "/")
lastPart := parts[len(parts)-1]
baseTemplateID := strings.TrimSuffix(lastPart, path.Ext(lastPart))
t, err := template.ParseFiles(baseTemplate, specificTemplate)
if err != nil {
return "", stacktrace.Propagate(err, "failed to parse templates")
}
err = t.ExecuteTemplate(htmlBody, baseTemplateID, templateData)
if err != nil {
return "", stacktrace.Propagate(err, "failed to execute template")
}
return htmlBody.String(), nil
}