This wrapper implementation for Golang reuses the existing C version of bsdiff as provided by @mendsley and wraps it into a Go package, abstracting away all the cgo work that would need to be done otherwise.

The library and the helper binaries go-bsdiff and go-bspatch can be installed like this:

go get -v github.com/icedream/go-bsdiff/...

For exact documentation of the library check out GoDoc.

Library functionality is provided both as a package bsdiff containing both methods Diff and Patch, or as subpackages diff and patch which each only link the wanted functionality.

Below example will generate a patch and apply it again in one go. This code is not safe against errors but it shows how to use the provided routines:

package main

import (
    "os"
    "github.com/icedream/go-bsdiff"
    // Or use the subpackages to only link what you need:
    //"github.com/icedream/go-bsdiff/diff"
    //"github.com/icedream/go-bsdiff/patch"
)

const (
    oldFilePath = "your_old_file.dat"
    newFilePath = "your_new_file.dat"
    patchFilePath = "the_generated.patch"
)

func generatePatch() error {
    oldFile, _ := os.Open(oldFilePath)
    defer oldFile.Close()
    newFile, _ := os.Open(newFilePath)
    defer newFile.Close()
    patchFile, _ := os.Create(patchFilePath)
    defer patchFile.Close()

    return bsdiff.Diff(oldFile, newFile, patchFile)
}

func applyPatch() error {
    oldFile, _ := os.Open(oldFilePath)
    defer oldFile.Close()
    newFile, _ := os.Create(newFilePath)
    defer newFile.Close()
    patchFile, _ := os.Open(patchFilePath)
    defer patchFile.Close()

    return bsdiff.Patch(oldFile, newFile, patchFile)
}

func main() {
    generatePatch()
    applyPatch()
}

The tools go-bsdiff and go-bspatch both provide a --help flag to print out all information but in their simplest form, they can be used like this:

# Creates a patch file $the_generated with differences from
# $your_old_file to $your_new_file.
go-bsdiff "$your_old_file" "$your_new_file" "$the_generated"

# Applies a patch file $the_generated on $your_old_file
# and saves the new file to $your_new_file.
go-bspatch "$your_old_file" "$your_new_file" "$the_generated"

There is a Go implementation of an older version of bsdiff called binarydist. The original bsdiff tool has since been updated so patches generating using the original tool are no longer compatible with the Go implementation. I don't know what the changes between the versions are and unfortunately I don't have the time to search for these changes and port them over as a pull request, otherwise I'd have done that instead.

Additionally, @mendsley has already done the extra work of rewriting the code to be embeddable in any application code as a library. So why not make use of cgo, which I was going to look into in more detail at some point anyways?