What version of Go are you using (go version)?

go version go1.8.3 linux/amd64

What operating system and processor architecture are you using (go env)?

GOARCH="amd64"
GOBIN=""
GOEXE=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOOS="linux"
GOPATH="/home/kazza/go-test"
GORACE=""
GOROOT="/usr/local/go"
GOTOOLDIR="/usr/local/go/pkg/tool/linux_amd64"
GCCGO="gccgo"
CC="gcc"
GOGCCFLAGS="-fPIC -m64 -pthread -fmessage-length=0 -fdebug-prefix-map=/tmp/go-build602983390=/tmp/go-build -gno-record-gcc-switches"
CXX="g++"
CGO_ENABLED="1"
PKG_CONFIG="pkg-config"
CGO_CFLAGS="-g -O2"
CGO_CPPFLAGS=""
CGO_CXXFLAGS="-g -O2"
CGO_FFLAGS="-g -O2"
CGO_LDFLAGS="-g -O2"

What did you do?

package main

// Demonstration of an issue that involves running the openssl BN_rand
// function in multiple goroutines. Sometimes the program will
// segfault.

/*
#cgo CFLAGS: -std=c99 -Wall -Wpedantic
#cgo LDFLAGS: -lcrypto
#include <openssl/bn.h>

void GO_OPENSSL_free_char(char *addr) {
  OPENSSL_free(addr);
}
*/
import "C"
import (
	"errors"
	"fmt"
	"sync"
)

// Generates a random integer using the openssl BN_rand function as a
// string.
func Generate() (err error, str string) {
	bn := C.BN_new()
	if ret := C.BN_rand(bn, 127, 0, 1) ; ret == 1 {
		str = "ok"
		if ret := C.BN_bn2dec(bn) ; ret != nil {
			str = C.GoString(ret)
			C.GO_OPENSSL_free_char(ret)
		} else {
			err = errors.New("Failed to convert bn into string")
		}
		C.BN_free(bn)
	} else {
		err = errors.New("Failed to generate random number")
	}
	return
}

// Define the number of threads and times each thread will execute an
// action
const (
	threads = 100
	actions = 1000
)

func main() {
	var wg sync.WaitGroup

	for i := 0; i < threads; i++ {
		wg.Add(1)
		go func() {
			for j := 0; j < actions; j++ {
				fmt.Print(".")
				if err, _ := Generate(); err != nil {
					fmt.Println(err)
				}
			}
			wg.Done()
		}()
	}

	wg.Wait()
	fmt.Println("\nDone!")
}

What did you expect to see?

The program execute without error.

What did you see instead?

When run with a single thread, the program works as expected. However, when run with multiple threads the program sometimes segfaults. I suspect this is a problem with the method that OpenSSL uses to generate random numbers by accessing uninitialised regions of memory, however, this is not repeatable within C by the equivalent program (using pthreads) so I have opened it here just to be sure.

I have tried compiling OpenSSL with the -DPURIFY that allows BN_rand to pass valgrind without warnings, but it still causes segfaults in go.

This is an issue for me as currently the only reliable way to generate xmldsig's in go is to bind against the xmlsec1 C library. This means, that when signing XML documents under heavy load can cause the application to crash.