Home | History | Annotate | Download | only in md5
      1 // Copyright 2012 The Go Authors.  All rights reserved.
      2 // Use of this source code is governed by a BSD-style
      3 // license that can be found in the LICENSE file.
      4 
      5 // +build ignore
      6 
      7 // This program generates md5block.go
      8 // Invoke as
      9 //
     10 //	go run gen.go [-full] -output md5block.go
     11 //
     12 // The -full flag causes the generated code to do a full
     13 // (16x) unrolling instead of a 4x unrolling.
     14 
     15 package main
     16 
     17 import (
     18 	"bytes"
     19 	"flag"
     20 	"go/format"
     21 	"io/ioutil"
     22 	"log"
     23 	"strings"
     24 	"text/template"
     25 )
     26 
     27 var filename = flag.String("output", "md5block.go", "output file name")
     28 
     29 func main() {
     30 	flag.Parse()
     31 
     32 	var buf bytes.Buffer
     33 
     34 	t := template.Must(template.New("main").Funcs(funcs).Parse(program))
     35 	if err := t.Execute(&buf, data); err != nil {
     36 		log.Fatal(err)
     37 	}
     38 
     39 	data, err := format.Source(buf.Bytes())
     40 	if err != nil {
     41 		log.Fatal(err)
     42 	}
     43 	err = ioutil.WriteFile(*filename, data, 0644)
     44 	if err != nil {
     45 		log.Fatal(err)
     46 	}
     47 }
     48 
     49 type Data struct {
     50 	a, b, c, d string
     51 	Shift1     []int
     52 	Shift2     []int
     53 	Shift3     []int
     54 	Shift4     []int
     55 	Table1     []uint32
     56 	Table2     []uint32
     57 	Table3     []uint32
     58 	Table4     []uint32
     59 	Full       bool
     60 }
     61 
     62 var funcs = template.FuncMap{
     63 	"dup":     dup,
     64 	"relabel": relabel,
     65 	"rotate":  rotate,
     66 }
     67 
     68 func dup(count int, x []int) []int {
     69 	var out []int
     70 	for i := 0; i < count; i++ {
     71 		out = append(out, x...)
     72 	}
     73 	return out
     74 }
     75 
     76 func relabel(s string) string {
     77 	return strings.NewReplacer("a", data.a, "b", data.b, "c", data.c, "d", data.d).Replace(s)
     78 }
     79 
     80 func rotate() string {
     81 	data.a, data.b, data.c, data.d = data.d, data.a, data.b, data.c
     82 	return "" // no output
     83 }
     84 
     85 func init() {
     86 	flag.BoolVar(&data.Full, "full", false, "complete unrolling")
     87 }
     88 
     89 var data = Data{
     90 	a:      "a",
     91 	b:      "b",
     92 	c:      "c",
     93 	d:      "d",
     94 	Shift1: []int{7, 12, 17, 22},
     95 	Shift2: []int{5, 9, 14, 20},
     96 	Shift3: []int{4, 11, 16, 23},
     97 	Shift4: []int{6, 10, 15, 21},
     98 
     99 	// table[i] = int((1<<32) * abs(sin(i+1 radians))).
    100 	Table1: []uint32{
    101 		// round 1
    102 		0xd76aa478,
    103 		0xe8c7b756,
    104 		0x242070db,
    105 		0xc1bdceee,
    106 		0xf57c0faf,
    107 		0x4787c62a,
    108 		0xa8304613,
    109 		0xfd469501,
    110 		0x698098d8,
    111 		0x8b44f7af,
    112 		0xffff5bb1,
    113 		0x895cd7be,
    114 		0x6b901122,
    115 		0xfd987193,
    116 		0xa679438e,
    117 		0x49b40821,
    118 	},
    119 	Table2: []uint32{
    120 		// round 2
    121 		0xf61e2562,
    122 		0xc040b340,
    123 		0x265e5a51,
    124 		0xe9b6c7aa,
    125 		0xd62f105d,
    126 		0x2441453,
    127 		0xd8a1e681,
    128 		0xe7d3fbc8,
    129 		0x21e1cde6,
    130 		0xc33707d6,
    131 		0xf4d50d87,
    132 		0x455a14ed,
    133 		0xa9e3e905,
    134 		0xfcefa3f8,
    135 		0x676f02d9,
    136 		0x8d2a4c8a,
    137 	},
    138 	Table3: []uint32{
    139 		// round3
    140 		0xfffa3942,
    141 		0x8771f681,
    142 		0x6d9d6122,
    143 		0xfde5380c,
    144 		0xa4beea44,
    145 		0x4bdecfa9,
    146 		0xf6bb4b60,
    147 		0xbebfbc70,
    148 		0x289b7ec6,
    149 		0xeaa127fa,
    150 		0xd4ef3085,
    151 		0x4881d05,
    152 		0xd9d4d039,
    153 		0xe6db99e5,
    154 		0x1fa27cf8,
    155 		0xc4ac5665,
    156 	},
    157 	Table4: []uint32{
    158 		// round 4
    159 		0xf4292244,
    160 		0x432aff97,
    161 		0xab9423a7,
    162 		0xfc93a039,
    163 		0x655b59c3,
    164 		0x8f0ccc92,
    165 		0xffeff47d,
    166 		0x85845dd1,
    167 		0x6fa87e4f,
    168 		0xfe2ce6e0,
    169 		0xa3014314,
    170 		0x4e0811a1,
    171 		0xf7537e82,
    172 		0xbd3af235,
    173 		0x2ad7d2bb,
    174 		0xeb86d391,
    175 	},
    176 }
    177 
    178 var program = `// Copyright 2013 The Go Authors. All rights reserved.
    179 // Use of this source code is governed by a BSD-style
    180 // license that can be found in the LICENSE file.
    181 
    182 // DO NOT EDIT.
    183 // Generate with: go run gen.go{{if .Full}} -full{{end}} -output md5block.go
    184 
    185 package md5
    186 
    187 import (
    188 	"unsafe"
    189 	"runtime"
    190 )
    191 
    192 {{if not .Full}}
    193 	var t1 = [...]uint32{
    194 	{{range .Table1}}{{printf "\t%#x,\n" .}}{{end}}
    195 	}
    196 	
    197 	var t2 = [...]uint32{
    198 	{{range .Table2}}{{printf "\t%#x,\n" .}}{{end}}
    199 	}
    200 	
    201 	var t3 = [...]uint32{
    202 	{{range .Table3}}{{printf "\t%#x,\n" .}}{{end}}
    203 	}
    204 	
    205 	var t4 = [...]uint32{
    206 	{{range .Table4}}{{printf "\t%#x,\n" .}}{{end}}
    207 	}
    208 {{end}}
    209 
    210 const x86 = runtime.GOARCH == "amd64" || runtime.GOARCH == "386"
    211 
    212 var littleEndian bool
    213 
    214 func init() {
    215 	x := uint32(0x04030201)
    216 	y := [4]byte{0x1, 0x2, 0x3, 0x4}
    217 	littleEndian = *(*[4]byte)(unsafe.Pointer(&x)) == y
    218 }
    219 
    220 func blockGeneric(dig *digest, p []byte) {
    221 	a := dig.s[0]
    222 	b := dig.s[1]
    223 	c := dig.s[2]
    224 	d := dig.s[3]
    225 	var X *[16]uint32
    226 	var xbuf [16]uint32
    227 	for len(p) >= chunk {
    228 		aa, bb, cc, dd := a, b, c, d
    229 
    230 		// This is a constant condition - it is not evaluated on each iteration.
    231 		if x86 {
    232 			// MD5 was designed so that x86 processors can just iterate
    233 			// over the block data directly as uint32s, and we generate
    234 			// less code and run 1.3x faster if we take advantage of that.
    235 			// My apologies.
    236 			X = (*[16]uint32)(unsafe.Pointer(&p[0]))
    237 		} else if littleEndian && uintptr(unsafe.Pointer(&p[0]))&(unsafe.Alignof(uint32(0))-1) == 0 {
    238 			X = (*[16]uint32)(unsafe.Pointer(&p[0]))
    239 		} else {
    240 			X = &xbuf
    241 			j := 0
    242 			for i := 0; i < 16; i++ {
    243 				X[i&15] = uint32(p[j]) | uint32(p[j+1])<<8 | uint32(p[j+2])<<16 | uint32(p[j+3])<<24
    244 				j += 4
    245 			}
    246 		}
    247 
    248 		{{if .Full}}
    249 			// Round 1.
    250 			{{range $i, $s := dup 4 .Shift1}}
    251 				{{index $.Table1 $i | printf "a += (((c^d)&b)^d) + X[%d] + %d" $i | relabel}}
    252 				{{printf "a = a<<%d | a>>(32-%d) + b" $s $s | relabel}}
    253 				{{rotate}}
    254 			{{end}}
    255 	
    256 			// Round 2.
    257 			{{range $i, $s := dup 4 .Shift2}}
    258 				{{index $.Table2 $i | printf "a += (((b^c)&d)^c) + X[(1+5*%d)&15] + %d" $i | relabel}}
    259 				{{printf "a = a<<%d | a>>(32-%d) + b" $s $s | relabel}}
    260 				{{rotate}}
    261 			{{end}}
    262 	
    263 			// Round 3.
    264 			{{range $i, $s := dup 4 .Shift3}}
    265 				{{index $.Table3 $i | printf "a += (b^c^d) + X[(5+3*%d)&15] + %d" $i | relabel}}
    266 				{{printf "a = a<<%d | a>>(32-%d) + b" $s $s | relabel}}
    267 				{{rotate}}
    268 			{{end}}
    269 	
    270 			// Round 4.
    271 			{{range $i, $s := dup 4 .Shift4}}
    272 				{{index $.Table4 $i | printf "a += (c^(b|^d)) + X[(7*%d)&15] + %d" $i | relabel}}
    273 				{{printf "a = a<<%d | a>>(32-%d) + b" $s $s | relabel}}
    274 				{{rotate}}
    275 			{{end}}
    276 		{{else}}
    277 			// Round 1.
    278 			for i := uint(0); i < 16; {
    279 				{{range $s := .Shift1}}
    280 					{{printf "a += (((c^d)&b)^d) + X[i&15] + t1[i&15]" | relabel}}
    281 					{{printf "a = a<<%d | a>>(32-%d) + b" $s $s | relabel}}
    282 					i++
    283 					{{rotate}}
    284 				{{end}}
    285 			}
    286 	
    287 			// Round 2.
    288 			for i := uint(0); i < 16; {
    289 				{{range $s := .Shift2}}
    290 					{{printf "a += (((b^c)&d)^c) + X[(1+5*i)&15] + t2[i&15]" | relabel}}
    291 					{{printf "a = a<<%d | a>>(32-%d) + b" $s $s | relabel}}
    292 					i++
    293 					{{rotate}}
    294 				{{end}}
    295 			}
    296 	
    297 			// Round 3.
    298 			for i := uint(0); i < 16; {
    299 				{{range $s := .Shift3}}
    300 					{{printf "a += (b^c^d) + X[(5+3*i)&15] + t3[i&15]" | relabel}}
    301 					{{printf "a = a<<%d | a>>(32-%d) + b" $s $s | relabel}}
    302 					i++
    303 					{{rotate}}
    304 				{{end}}
    305 			}
    306 	
    307 			// Round 4.
    308 			for i := uint(0); i < 16; {
    309 				{{range $s := .Shift4}}
    310 					{{printf "a += (c^(b|^d)) + X[(7*i)&15] + t4[i&15]" | relabel}}
    311 					{{printf "a = a<<%d | a>>(32-%d) + b" $s $s | relabel}}
    312 					i++
    313 					{{rotate}}
    314 				{{end}}
    315 			}
    316 		{{end}}
    317 
    318 		a += aa
    319 		b += bb
    320 		c += cc
    321 		d += dd
    322 
    323 		p = p[chunk:]
    324 	}
    325 
    326 	dig.s[0] = a
    327 	dig.s[1] = b
    328 	dig.s[2] = c
    329 	dig.s[3] = d
    330 }
    331 `
    332