package main
import (
- "crypto/md5"
"flag"
"fmt"
"go/ast"
"strings"
"cmd/internal/edit"
+ "cmd/internal/notsha256"
"cmd/internal/objabi"
)
// we use to coordinate between gcc and ourselves.
// We already put _cgo_ at the beginning, so the main
// concern is other cgo wrappers for the same functions.
- // Use the beginning of the md5 of the input to disambiguate.
- h := md5.New()
+ // Use the beginning of the notsha256 of the input to disambiguate.
+ h := notsha256.New()
io.WriteString(h, *importPath)
fs := make([]*File, len(goFiles))
for i, input := range goFiles {
package liveness
import (
- "crypto/sha1"
"fmt"
"os"
"sort"
"cmd/compile/internal/ssa"
"cmd/compile/internal/typebits"
"cmd/compile/internal/types"
+ "cmd/internal/notsha256"
"cmd/internal/obj"
"cmd/internal/objabi"
"cmd/internal/src"
// Clobber only functions where the hash of the function name matches a pattern.
// Useful for binary searching for a miscompiled function.
hstr := ""
- for _, b := range sha1.Sum([]byte(lv.f.Name)) {
+ for _, b := range notsha256.Sum256([]byte(lv.f.Name)) {
hstr += fmt.Sprintf("%08b", b)
}
if !strings.HasSuffix(hstr, h) {
"cmd/compile/internal/abi"
"cmd/compile/internal/base"
"cmd/compile/internal/types"
+ "cmd/internal/notsha256"
"cmd/internal/src"
- "crypto/sha1"
"fmt"
"io"
"math"
// We use this feature to do a binary search to
// find a function that is incorrectly compiled.
hstr := ""
- for _, b := range sha1.Sum([]byte(name)) {
+ for _, b := range notsha256.Sum256([]byte(name)) {
hstr += fmt.Sprintf("%08b", b)
}
import (
"bytes"
- "cmd/internal/src"
- "crypto/sha256"
"fmt"
"io"
+
+ "cmd/internal/notsha256"
+ "cmd/internal/src"
)
func printFunc(f *Func) {
}
func hashFunc(f *Func) []byte {
- h := sha256.New()
+ h := notsha256.New()
p := stringFuncPrinter{w: h, printDead: true}
fprintFunc(p, f)
return h.Sum(nil)
// rewriteHash returns a hash of f suitable for detecting rewrite cycles.
func (f *Func) rewriteHash() string {
- h := sha256.New()
+ h := notsha256.New()
p := stringFuncPrinter{w: h, printDead: false}
fprintFunc(p, f)
return fmt.Sprintf("%x", h.Sum(nil))
package staticdata
import (
- "crypto/sha256"
"fmt"
"go/constant"
"io"
"cmd/compile/internal/objw"
"cmd/compile/internal/typecheck"
"cmd/compile/internal/types"
+ "cmd/internal/notsha256"
"cmd/internal/obj"
"cmd/internal/objabi"
"cmd/internal/src"
// Indulge in some paranoia by writing the length of s, too,
// as protection against length extension attacks.
// Same pattern is known to fileStringSym below.
- h := sha256.New()
+ h := notsha256.New()
io.WriteString(h, s)
symname = fmt.Sprintf(stringSymPattern, len(s), h.Sum(nil))
} else {
sym = slicedata(pos, string(data)).Linksym()
}
if len(hash) > 0 {
- sum := sha256.Sum256(data)
+ sum := notsha256.Sum256(data)
copy(hash, sum[:])
}
return sym, size, nil
// Compute hash if needed for read-only content hashing or if the caller wants it.
var sum []byte
if readonly || len(hash) > 0 {
- h := sha256.New()
+ h := notsha256.New()
n, err := io.Copy(h, f)
if err != nil {
return nil, 0, err
import (
"bytes"
- "crypto/md5"
"encoding/binary"
"fmt"
"go/constant"
"cmd/compile/internal/ir"
"cmd/compile/internal/types"
"cmd/internal/goobj"
+ "cmd/internal/notsha256"
"cmd/internal/src"
)
hdr.uint64(dataLen)
// Flush output.
- h := md5.New()
+ h := notsha256.New()
wr := io.MultiWriter(out, h)
io.Copy(wr, &hdr)
io.Copy(wr, &p.strings)
import (
"bytes"
- "crypto/md5"
"encoding/binary"
"fmt"
"go/constant"
"sync"
"cmd/compile/internal/base"
+ "cmd/internal/notsha256"
)
// BuiltinPkg is a fake package that declares the universe block.
func TypeHash(t *Type) uint32 {
p := tconv(t, 0, fmtTypeIDHash)
- // Using MD5 is overkill, but reduces accidental collisions.
- h := md5.Sum([]byte(p))
+ // Using SHA256 is overkill, but reduces accidental collisions.
+ h := notsha256.Sum256([]byte(p))
return binary.LittleEndian.Uint32(h[:4])
}
"cmd/internal/edit",
"cmd/internal/gcprog",
"cmd/internal/goobj",
+ "cmd/internal/notsha256",
"cmd/internal/obj/...",
"cmd/internal/objabi",
"cmd/internal/pkgpath",
package codesign
import (
- "crypto/sha256"
"debug/macho"
"encoding/binary"
"io"
+
+ "cmd/internal/notsha256"
)
// Code signature layout.
nhashes := (codeSize + pageSize - 1) / pageSize
idOff := int64(codeDirectorySize)
hashOff := idOff + int64(len(id)+1)
- cdirSz := hashOff + nhashes*sha256.Size
+ cdirSz := hashOff + nhashes*notsha256.Size
return int64(superBlobSize+blobSize) + cdirSz
}
identOffset: uint32(idOff),
nCodeSlots: uint32(nhashes),
codeLimit: uint32(codeSize),
- hashSize: sha256.Size,
+ hashSize: notsha256.Size,
hashType: CS_HASHTYPE_SHA256,
pageSize: uint8(pageSizeBits),
execSegBase: uint64(textOff),
outp = puts(outp, []byte(id+"\000"))
// emit hashes
+ // NOTE(rsc): These must be SHA256, but for cgo bootstrap reasons
+ // we cannot import crypto/sha256 when GOEXPERIMENT=boringcrypto
+ // and the host is linux/amd64. So we use NOT-SHA256
+ // and then apply a NOT ourselves to get SHA256. Sigh.
var buf [pageSize]byte
- h := sha256.New()
+ h := notsha256.New()
p := 0
for p < int(codeSize) {
n, err := io.ReadFull(data, buf[:])
h.Reset()
h.Write(buf[:n])
b := h.Sum(nil)
+ for i := range b {
+ b[i] ^= 0xFF // convert notsha256 to sha256
+ }
outp = puts(outp, b[:])
}
}
import (
"cmd/internal/bio"
- "crypto/sha1"
+ "cmd/internal/notsha256"
"encoding/binary"
"errors"
"fmt"
// Hash
type HashType [HashSize]byte
-const HashSize = sha1.Size
+const HashSize = notsha256.Size
// Relocation.
//
"bytes"
"cmd/internal/bio"
"cmd/internal/goobj"
+ "cmd/internal/notsha256"
"cmd/internal/objabi"
"cmd/internal/sys"
- "crypto/sha1"
"encoding/binary"
"fmt"
"io"
// For now, we assume there is no circular dependencies among
// hashed symbols.
func (w *writer) contentHash(s *LSym) goobj.HashType {
- h := sha1.New()
+ h := notsha256.New()
var tmp [14]byte
// Include the size of the symbol in the hash.
import (
"cmd/internal/goobj"
+ "cmd/internal/notsha256"
"cmd/internal/objabi"
- "crypto/md5"
"fmt"
"internal/buildcfg"
"log"
// GCLocalsSym generates a content-addressable sym containing data.
func (ctxt *Link) GCLocalsSym(data []byte) *LSym {
- return ctxt.LookupInit(fmt.Sprintf("gclocals·%x", md5.Sum(data)), func(lsym *LSym) {
+ return ctxt.LookupInit(fmt.Sprintf("gclocals·%x", notsha256.Sum256(data)), func(lsym *LSym) {
lsym.P = data
lsym.Set(AttrContentAddressable, true)
})
package ld
import (
+ "cmd/internal/notsha256"
"cmd/internal/objabi"
"cmd/internal/sys"
"cmd/link/internal/loader"
"cmd/link/internal/sym"
- "crypto/sha1"
"debug/elf"
"encoding/binary"
"encoding/hex"
sb.SetType(sym.SRODATA)
ldr.SetAttrSpecial(s, true)
sb.SetReachable(true)
- sb.SetSize(sha1.Size)
+ sb.SetSize(notsha256.Size)
sort.Sort(byPkg(ctxt.Library))
- h := sha1.New()
+ h := notsha256.New()
for _, l := range ctxt.Library {
h.Write(l.Fingerprint[:])
}
"bytes"
"cmd/internal/bio"
"cmd/internal/goobj"
+ "cmd/internal/notsha256"
"cmd/internal/objabi"
"cmd/internal/sys"
"cmd/link/internal/loadelf"
"cmd/link/internal/loadpe"
"cmd/link/internal/loadxcoff"
"cmd/link/internal/sym"
- "crypto/sha1"
"debug/elf"
"debug/macho"
"encoding/base64"
if len(name) <= 14 && !strings.Contains(name, "@") { // Issue 19529
return name
}
- hash := sha1.Sum([]byte(name))
+ hash := notsha256.Sum256([]byte(name))
prefix := "type."
if name[5] == '.' {
prefix = "type.."
package main
import (
- "crypto/md5"
+ "cmd/internal/notsha256"
"flag"
"fmt"
"go/build"
goarch = f[1]
}
- hash := md5.Sum([]byte(fmt.Sprintf("%v-%v-%v-%v", srcfname, flags, printCode, printGnuAsm)))
+ hash := notsha256.Sum256([]byte(fmt.Sprintf("%v-%v-%v-%v", srcfname, flags, printCode, printGnuAsm)))
hello := filepath.Join(tmp, fmt.Sprintf("hello-%x.exe", hash))
args := []string{"build", "-o", hello}
args = append(args, flags...)