这比预期的要困难得多。我提到了这个资源，它解释了JPEG作为片段流的一般结构，唯一的例外是保存实际图像数据的“熵编码片段”（ECS）。

方法问题

我的想法是从标签源文件复制所有内容，直到第一个ffdb被排除，然后从图像源文件（没有标签）复制所有内容，从第一个ffdb开始。生成的文件已损坏（缺少SOS标记）。
这使得非常强烈的假设JPEG文件将不会举行。首先，ffdb可以很好地出现在 * 段内的某个地方 *。段的顺序也很松散，所以你不能保证ffdb（定义量化表的段）之前或之后是什么。即使它在大部分时间里都能工作，它仍然是一个非常脆弱，不可靠的解决方案。

正确方法

正确的方法是 * 迭代所有片段 *，仅从提供元数据的文件复制元数据片段，并且仅从提供图像数据的文件复制非元数据片段。
使这复杂化的是，出于某种原因，ECS不遵循段约定。因此，在阅读SOS（扫描开始）之后，我们需要通过查找下一个段标签跳到ECS的结尾：0xFF，后跟一个字节，该字节可能既不是数据（零），也不是“重启标记”（0xD0-0xD7）。
为了测试，我使用了this image with EXIF metadata。我的测试命令如下所示：

cp exif.jpg exif_stripped.jpg && exiftool -All= exif_stripped.jpg && go run main.go exif.jpg exif_stripped.jpg

字符串
我使用exiftool剥离EXIF元数据，然后通过重新读取它来测试Go程序。然后，使用exiftool exif_stripped.jpg（或您选择的图像查看器）查看元数据，并与exiftool exif.jpg的输出进行比较（附注：你可以简单地使用exiftool来完全废弃这个Go程序）。
我编写的程序取代了EXIF元数据、注解和版权声明。我添加了一个简单的命令行界面用于测试。如果只想保留EXIF元数据，只需将isMetaTagType函数更改为

func isMetaTagType(tagType byte) bool { return tagType == exif }

型

完整程序

package main

import (
    "os"
    "io"
    "bufio"
    "errors"
)

const (
    soi = 0xD8
    eoi = 0xD9
    sos = 0xDA
    exif = 0xE1
    copyright = 0xEE
    comment = 0xFE
)

func isMetaTagType(tagType byte) bool {
    // Adapt as needed
    return tagType == exif || tagType == copyright || tagType == comment
}

func copySegments(dst *bufio.Writer, src *bufio.Reader, filterSegment func(tagType byte) bool) error {
    var buf [2]byte
    _, err := io.ReadFull(src, buf[:])
    if err != nil { return err }
    if buf != [2]byte{0xFF, soi} {
        return errors.New("expected SOI")
    }
    for {
        _, err := io.ReadFull(src, buf[:])
        if err != nil { return err }
        if buf[0] != 0xFF {
            return errors.New("invalid tag type")
        }
        if buf[1] == eoi {
            // Hacky way to check for EOF
            n, err := src.Read(buf[:1])
            if err != nil && err != io.EOF { return err }
            if n > 0 {
                return errors.New("EOF expected after EOI")
            }
            return nil
        }
        sos := buf[1] == 0xDA
        filter := filterSegment(buf[1])
        if filter {
            _, err = dst.Write(buf[:])
            if err != nil { return err }
        }

        _, err = io.ReadFull(src, buf[:])
        if err != nil { return err }
        if filter {
            _, err = dst.Write(buf[:])
            if err != nil { return err }
        }

        // Note: Includes the length, but not the tag, so subtract 2
        tagLength := ((uint16(buf[0]) << 8) | uint16(buf[1])) - 2
        if filter {
            _, err = io.CopyN(dst, src, int64(tagLength))
        } else {
            _, err = src.Discard(int(tagLength))
        }
        if err != nil { return err }
        if sos {
            // Find next tag `FF xx` in the stream where `xx != 0` to skip ECS
            // See https://stackoverflow.com/questions/2467137/parsing-jpeg-file-format-format-of-entropy-coded-segments-ecs
            for {
                bytes, err := src.Peek(2)
                if err != nil { return err }
                if bytes[0] == 0xFF {
                    data, rstMrk := bytes[1] == 0, bytes[1] >= 0xD0 && bytes[1] <= 0xD7
                    if !data && !rstMrk {
                        break
                    }
                }
                if filter {
                    err = dst.WriteByte(bytes[0])
                    if err != nil { return err }
                }
                _, err = src.Discard(1)
                if err != nil { return err }
            }
        }
    }
}

func copyMetadata(outImagePath, imagePath, metadataImagePath string) error {
    outFile, err := os.Create(outImagePath)
    if err != nil { return err }
    defer outFile.Close()
    writer := bufio.NewWriter(outFile)

    imageFile, err := os.Open(imagePath)
    if err != nil { return err }
    defer imageFile.Close()
    imageReader := bufio.NewReader(imageFile)

    metaFile, err := os.Open(metadataImagePath)
    if err != nil { return err }
    defer metaFile.Close()
    metaReader := bufio.NewReader(metaFile)

    _, err = writer.Write([]byte{0xFF, soi})
    if err != nil { return err }
    {
        // Copy metadata segments
        // It seems that they need to come first!
        err = copySegments(writer, metaReader, isMetaTagType)
        if err != nil { return err }
        // Copy all non-metadata segments
        err = copySegments(writer, imageReader, func(tagType byte) bool {
            return !isMetaTagType(tagType)
        })
        if err != nil { return err }
    }
    _, err = writer.Write([]byte{0xFF, eoi})
    if err != nil { return err }

    // Flush the writer, otherwise the last couple buffered writes (including the EOI) won't get written!
    return writer.Flush()
}

func replaceMetadata(toPath, fromPath string) error {
    copyPath := toPath + "~"
    err := os.Rename(toPath, copyPath)
    if err != nil { return err }
    defer os.Remove(copyPath)
    return copyMetadata(toPath, copyPath, fromPath)
}

func main() {
    if len(os.Args) < 3 {
        println("args: FROM TO")
        return
    }
    err := replaceMetadata(os.Args[2], os.Args[1])
    if err != nil {
        println("replacing metadata failed: " + err.Error())
    }
}

型