| // Copyright 2012 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // +build !amd64,!arm gccgo appengine nacl |
| |
| package poly1305 |
| |
| // Based on original, public domain implementation from NaCl by D. J. |
| // Bernstein. |
| |
| import "math" |
| |
| const ( |
| alpham80 = 0.00000000558793544769287109375 |
| alpham48 = 24.0 |
| alpham16 = 103079215104.0 |
| alpha0 = 6755399441055744.0 |
| alpha18 = 1770887431076116955136.0 |
| alpha32 = 29014219670751100192948224.0 |
| alpha50 = 7605903601369376408980219232256.0 |
| alpha64 = 124615124604835863084731911901282304.0 |
| alpha82 = 32667107224410092492483962313449748299776.0 |
| alpha96 = 535217884764734955396857238543560676143529984.0 |
| alpha112 = 35076039295941670036888435985190792471742381031424.0 |
| alpha130 = 9194973245195333150150082162901855101712434733101613056.0 |
| scale = 0.0000000000000000000000000000000000000036734198463196484624023016788195177431833298649127735047148490821200539357960224151611328125 |
| offset0 = 6755408030990331.0 |
| offset1 = 29014256564239239022116864.0 |
| offset2 = 124615283061160854719918951570079744.0 |
| offset3 = 535219245894202480694386063513315216128475136.0 |
| ) |
| |
| // Sum generates an authenticator for m using a one-time key and puts the |
| // 16-byte result into out. Authenticating two different messages with the same |
| // key allows an attacker to forge messages at will. |
| func Sum(out *[16]byte, m []byte, key *[32]byte) { |
| r := key |
| s := key[16:] |
| var ( |
| y7 float64 |
| y6 float64 |
| y1 float64 |
| y0 float64 |
| y5 float64 |
| y4 float64 |
| x7 float64 |
| x6 float64 |
| x1 float64 |
| x0 float64 |
| y3 float64 |
| y2 float64 |
| x5 float64 |
| r3lowx0 float64 |
| x4 float64 |
| r0lowx6 float64 |
| x3 float64 |
| r3highx0 float64 |
| x2 float64 |
| r0highx6 float64 |
| r0lowx0 float64 |
| sr1lowx6 float64 |
| r0highx0 float64 |
| sr1highx6 float64 |
| sr3low float64 |
| r1lowx0 float64 |
| sr2lowx6 float64 |
| r1highx0 float64 |
| sr2highx6 float64 |
| r2lowx0 float64 |
| sr3lowx6 float64 |
| r2highx0 float64 |
| sr3highx6 float64 |
| r1highx4 float64 |
| r1lowx4 float64 |
| r0highx4 float64 |
| r0lowx4 float64 |
| sr3highx4 float64 |
| sr3lowx4 float64 |
| sr2highx4 float64 |
| sr2lowx4 float64 |
| r0lowx2 float64 |
| r0highx2 float64 |
| r1lowx2 float64 |
| r1highx2 float64 |
| r2lowx2 float64 |
| r2highx2 float64 |
| sr3lowx2 float64 |
| sr3highx2 float64 |
| z0 float64 |
| z1 float64 |
| z2 float64 |
| z3 float64 |
| m0 int64 |
| m1 int64 |
| m2 int64 |
| m3 int64 |
| m00 uint32 |
| m01 uint32 |
| m02 uint32 |
| m03 uint32 |
| m10 uint32 |
| m11 uint32 |
| m12 uint32 |
| m13 uint32 |
| m20 uint32 |
| m21 uint32 |
| m22 uint32 |
| m23 uint32 |
| m30 uint32 |
| m31 uint32 |
| m32 uint32 |
| m33 uint64 |
| lbelow2 int32 |
| lbelow3 int32 |
| lbelow4 int32 |
| lbelow5 int32 |
| lbelow6 int32 |
| lbelow7 int32 |
| lbelow8 int32 |
| lbelow9 int32 |
| lbelow10 int32 |
| lbelow11 int32 |
| lbelow12 int32 |
| lbelow13 int32 |
| lbelow14 int32 |
| lbelow15 int32 |
| s00 uint32 |
| s01 uint32 |
| s02 uint32 |
| s03 uint32 |
| s10 uint32 |
| s11 uint32 |
| s12 uint32 |
| s13 uint32 |
| s20 uint32 |
| s21 uint32 |
| s22 uint32 |
| s23 uint32 |
| s30 uint32 |
| s31 uint32 |
| s32 uint32 |
| s33 uint32 |
| bits32 uint64 |
| f uint64 |
| f0 uint64 |
| f1 uint64 |
| f2 uint64 |
| f3 uint64 |
| f4 uint64 |
| g uint64 |
| g0 uint64 |
| g1 uint64 |
| g2 uint64 |
| g3 uint64 |
| g4 uint64 |
| ) |
| |
| var p int32 |
| |
| l := int32(len(m)) |
| |
| r00 := uint32(r[0]) |
| |
| r01 := uint32(r[1]) |
| |
| r02 := uint32(r[2]) |
| r0 := int64(2151) |
| |
| r03 := uint32(r[3]) |
| r03 &= 15 |
| r0 <<= 51 |
| |
| r10 := uint32(r[4]) |
| r10 &= 252 |
| r01 <<= 8 |
| r0 += int64(r00) |
| |
| r11 := uint32(r[5]) |
| r02 <<= 16 |
| r0 += int64(r01) |
| |
| r12 := uint32(r[6]) |
| r03 <<= 24 |
| r0 += int64(r02) |
| |
| r13 := uint32(r[7]) |
| r13 &= 15 |
| r1 := int64(2215) |
| r0 += int64(r03) |
| |
| d0 := r0 |
| r1 <<= 51 |
| r2 := int64(2279) |
| |
| r20 := uint32(r[8]) |
| r20 &= 252 |
| r11 <<= 8 |
| r1 += int64(r10) |
| |
| r21 := uint32(r[9]) |
| r12 <<= 16 |
| r1 += int64(r11) |
| |
| r22 := uint32(r[10]) |
| r13 <<= 24 |
| r1 += int64(r12) |
| |
| r23 := uint32(r[11]) |
| r23 &= 15 |
| r2 <<= 51 |
| r1 += int64(r13) |
| |
| d1 := r1 |
| r21 <<= 8 |
| r2 += int64(r20) |
| |
| r30 := uint32(r[12]) |
| r30 &= 252 |
| r22 <<= 16 |
| r2 += int64(r21) |
| |
| r31 := uint32(r[13]) |
| r23 <<= 24 |
| r2 += int64(r22) |
| |
| r32 := uint32(r[14]) |
| r2 += int64(r23) |
| r3 := int64(2343) |
| |
| d2 := r2 |
| r3 <<= 51 |
| |
| r33 := uint32(r[15]) |
| r33 &= 15 |
| r31 <<= 8 |
| r3 += int64(r30) |
| |
| r32 <<= 16 |
| r3 += int64(r31) |
| |
| r33 <<= 24 |
| r3 += int64(r32) |
| |
| r3 += int64(r33) |
| h0 := alpha32 - alpha32 |
| |
| d3 := r3 |
| h1 := alpha32 - alpha32 |
| |
| h2 := alpha32 - alpha32 |
| |
| h3 := alpha32 - alpha32 |
| |
| h4 := alpha32 - alpha32 |
| |
| r0low := math.Float64frombits(uint64(d0)) |
| h5 := alpha32 - alpha32 |
| |
| r1low := math.Float64frombits(uint64(d1)) |
| h6 := alpha32 - alpha32 |
| |
| r2low := math.Float64frombits(uint64(d2)) |
| h7 := alpha32 - alpha32 |
| |
| r0low -= alpha0 |
| |
| r1low -= alpha32 |
| |
| r2low -= alpha64 |
| |
| r0high := r0low + alpha18 |
| |
| r3low := math.Float64frombits(uint64(d3)) |
| |
| r1high := r1low + alpha50 |
| sr1low := scale * r1low |
| |
| r2high := r2low + alpha82 |
| sr2low := scale * r2low |
| |
| r0high -= alpha18 |
| r0high_stack := r0high |
| |
| r3low -= alpha96 |
| |
| r1high -= alpha50 |
| r1high_stack := r1high |
| |
| sr1high := sr1low + alpham80 |
| |
| r0low -= r0high |
| |
| r2high -= alpha82 |
| sr3low = scale * r3low |
| |
| sr2high := sr2low + alpham48 |
| |
| r1low -= r1high |
| r1low_stack := r1low |
| |
| sr1high -= alpham80 |
| sr1high_stack := sr1high |
| |
| r2low -= r2high |
| r2low_stack := r2low |
| |
| sr2high -= alpham48 |
| sr2high_stack := sr2high |
| |
| r3high := r3low + alpha112 |
| r0low_stack := r0low |
| |
| sr1low -= sr1high |
| sr1low_stack := sr1low |
| |
| sr3high := sr3low + alpham16 |
| r2high_stack := r2high |
| |
| sr2low -= sr2high |
| sr2low_stack := sr2low |
| |
| r3high -= alpha112 |
| r3high_stack := r3high |
| |
| sr3high -= alpham16 |
| sr3high_stack := sr3high |
| |
| r3low -= r3high |
| r3low_stack := r3low |
| |
| sr3low -= sr3high |
| sr3low_stack := sr3low |
| |
| if l < 16 { |
| goto addatmost15bytes |
| } |
| |
| m00 = uint32(m[p+0]) |
| m0 = 2151 |
| |
| m0 <<= 51 |
| m1 = 2215 |
| m01 = uint32(m[p+1]) |
| |
| m1 <<= 51 |
| m2 = 2279 |
| m02 = uint32(m[p+2]) |
| |
| m2 <<= 51 |
| m3 = 2343 |
| m03 = uint32(m[p+3]) |
| |
| m10 = uint32(m[p+4]) |
| m01 <<= 8 |
| m0 += int64(m00) |
| |
| m11 = uint32(m[p+5]) |
| m02 <<= 16 |
| m0 += int64(m01) |
| |
| m12 = uint32(m[p+6]) |
| m03 <<= 24 |
| m0 += int64(m02) |
| |
| m13 = uint32(m[p+7]) |
| m3 <<= 51 |
| m0 += int64(m03) |
| |
| m20 = uint32(m[p+8]) |
| m11 <<= 8 |
| m1 += int64(m10) |
| |
| m21 = uint32(m[p+9]) |
| m12 <<= 16 |
| m1 += int64(m11) |
| |
| m22 = uint32(m[p+10]) |
| m13 <<= 24 |
| m1 += int64(m12) |
| |
| m23 = uint32(m[p+11]) |
| m1 += int64(m13) |
| |
| m30 = uint32(m[p+12]) |
| m21 <<= 8 |
| m2 += int64(m20) |
| |
| m31 = uint32(m[p+13]) |
| m22 <<= 16 |
| m2 += int64(m21) |
| |
| m32 = uint32(m[p+14]) |
| m23 <<= 24 |
| m2 += int64(m22) |
| |
| m33 = uint64(m[p+15]) |
| m2 += int64(m23) |
| |
| d0 = m0 |
| m31 <<= 8 |
| m3 += int64(m30) |
| |
| d1 = m1 |
| m32 <<= 16 |
| m3 += int64(m31) |
| |
| d2 = m2 |
| m33 += 256 |
| |
| m33 <<= 24 |
| m3 += int64(m32) |
| |
| m3 += int64(m33) |
| d3 = m3 |
| |
| p += 16 |
| l -= 16 |
| |
| z0 = math.Float64frombits(uint64(d0)) |
| |
| z1 = math.Float64frombits(uint64(d1)) |
| |
| z2 = math.Float64frombits(uint64(d2)) |
| |
| z3 = math.Float64frombits(uint64(d3)) |
| |
| z0 -= alpha0 |
| |
| z1 -= alpha32 |
| |
| z2 -= alpha64 |
| |
| z3 -= alpha96 |
| |
| h0 += z0 |
| |
| h1 += z1 |
| |
| h3 += z2 |
| |
| h5 += z3 |
| |
| if l < 16 { |
| goto multiplyaddatmost15bytes |
| } |
| |
| multiplyaddatleast16bytes: |
| |
| m2 = 2279 |
| m20 = uint32(m[p+8]) |
| y7 = h7 + alpha130 |
| |
| m2 <<= 51 |
| m3 = 2343 |
| m21 = uint32(m[p+9]) |
| y6 = h6 + alpha130 |
| |
| m3 <<= 51 |
| m0 = 2151 |
| m22 = uint32(m[p+10]) |
| y1 = h1 + alpha32 |
| |
| m0 <<= 51 |
| m1 = 2215 |
| m23 = uint32(m[p+11]) |
| y0 = h0 + alpha32 |
| |
| m1 <<= 51 |
| m30 = uint32(m[p+12]) |
| y7 -= alpha130 |
| |
| m21 <<= 8 |
| m2 += int64(m20) |
| m31 = uint32(m[p+13]) |
| y6 -= alpha130 |
| |
| m22 <<= 16 |
| m2 += int64(m21) |
| m32 = uint32(m[p+14]) |
| y1 -= alpha32 |
| |
| m23 <<= 24 |
| m2 += int64(m22) |
| m33 = uint64(m[p+15]) |
| y0 -= alpha32 |
| |
| m2 += int64(m23) |
| m00 = uint32(m[p+0]) |
| y5 = h5 + alpha96 |
| |
| m31 <<= 8 |
| m3 += int64(m30) |
| m01 = uint32(m[p+1]) |
| y4 = h4 + alpha96 |
| |
| m32 <<= 16 |
| m02 = uint32(m[p+2]) |
| x7 = h7 - y7 |
| y7 *= scale |
| |
| m33 += 256 |
| m03 = uint32(m[p+3]) |
| x6 = h6 - y6 |
| y6 *= scale |
| |
| m33 <<= 24 |
| m3 += int64(m31) |
| m10 = uint32(m[p+4]) |
| x1 = h1 - y1 |
| |
| m01 <<= 8 |
| m3 += int64(m32) |
| m11 = uint32(m[p+5]) |
| x0 = h0 - y0 |
| |
| m3 += int64(m33) |
| m0 += int64(m00) |
| m12 = uint32(m[p+6]) |
| y5 -= alpha96 |
| |
| m02 <<= 16 |
| m0 += int64(m01) |
| m13 = uint32(m[p+7]) |
| y4 -= alpha96 |
| |
| m03 <<= 24 |
| m0 += int64(m02) |
| d2 = m2 |
| x1 += y7 |
| |
| m0 += int64(m03) |
| d3 = m3 |
| x0 += y6 |
| |
| m11 <<= 8 |
| m1 += int64(m10) |
| d0 = m0 |
| x7 += y5 |
| |
| m12 <<= 16 |
| m1 += int64(m11) |
| x6 += y4 |
| |
| m13 <<= 24 |
| m1 += int64(m12) |
| y3 = h3 + alpha64 |
| |
| m1 += int64(m13) |
| d1 = m1 |
| y2 = h2 + alpha64 |
| |
| x0 += x1 |
| |
| x6 += x7 |
| |
| y3 -= alpha64 |
| r3low = r3low_stack |
| |
| y2 -= alpha64 |
| r0low = r0low_stack |
| |
| x5 = h5 - y5 |
| r3lowx0 = r3low * x0 |
| r3high = r3high_stack |
| |
| x4 = h4 - y4 |
| r0lowx6 = r0low * x6 |
| r0high = r0high_stack |
| |
| x3 = h3 - y3 |
| r3highx0 = r3high * x0 |
| sr1low = sr1low_stack |
| |
| x2 = h2 - y2 |
| r0highx6 = r0high * x6 |
| sr1high = sr1high_stack |
| |
| x5 += y3 |
| r0lowx0 = r0low * x0 |
| r1low = r1low_stack |
| |
| h6 = r3lowx0 + r0lowx6 |
| sr1lowx6 = sr1low * x6 |
| r1high = r1high_stack |
| |
| x4 += y2 |
| r0highx0 = r0high * x0 |
| sr2low = sr2low_stack |
| |
| h7 = r3highx0 + r0highx6 |
| sr1highx6 = sr1high * x6 |
| sr2high = sr2high_stack |
| |
| x3 += y1 |
| r1lowx0 = r1low * x0 |
| r2low = r2low_stack |
| |
| h0 = r0lowx0 + sr1lowx6 |
| sr2lowx6 = sr2low * x6 |
| r2high = r2high_stack |
| |
| x2 += y0 |
| r1highx0 = r1high * x0 |
| sr3low = sr3low_stack |
| |
| h1 = r0highx0 + sr1highx6 |
| sr2highx6 = sr2high * x6 |
| sr3high = sr3high_stack |
| |
| x4 += x5 |
| r2lowx0 = r2low * x0 |
| z2 = math.Float64frombits(uint64(d2)) |
| |
| h2 = r1lowx0 + sr2lowx6 |
| sr3lowx6 = sr3low * x6 |
| |
| x2 += x3 |
| r2highx0 = r2high * x0 |
| z3 = math.Float64frombits(uint64(d3)) |
| |
| h3 = r1highx0 + sr2highx6 |
| sr3highx6 = sr3high * x6 |
| |
| r1highx4 = r1high * x4 |
| z2 -= alpha64 |
| |
| h4 = r2lowx0 + sr3lowx6 |
| r1lowx4 = r1low * x4 |
| |
| r0highx4 = r0high * x4 |
| z3 -= alpha96 |
| |
| h5 = r2highx0 + sr3highx6 |
| r0lowx4 = r0low * x4 |
| |
| h7 += r1highx4 |
| sr3highx4 = sr3high * x4 |
| |
| h6 += r1lowx4 |
| sr3lowx4 = sr3low * x4 |
| |
| h5 += r0highx4 |
| sr2highx4 = sr2high * x4 |
| |
| h4 += r0lowx4 |
| sr2lowx4 = sr2low * x4 |
| |
| h3 += sr3highx4 |
| r0lowx2 = r0low * x2 |
| |
| h2 += sr3lowx4 |
| r0highx2 = r0high * x2 |
| |
| h1 += sr2highx4 |
| r1lowx2 = r1low * x2 |
| |
| h0 += sr2lowx4 |
| r1highx2 = r1high * x2 |
| |
| h2 += r0lowx2 |
| r2lowx2 = r2low * x2 |
| |
| h3 += r0highx2 |
| r2highx2 = r2high * x2 |
| |
| h4 += r1lowx2 |
| sr3lowx2 = sr3low * x2 |
| |
| h5 += r1highx2 |
| sr3highx2 = sr3high * x2 |
| |
| p += 16 |
| l -= 16 |
| h6 += r2lowx2 |
| |
| h7 += r2highx2 |
| |
| z1 = math.Float64frombits(uint64(d1)) |
| h0 += sr3lowx2 |
| |
| z0 = math.Float64frombits(uint64(d0)) |
| h1 += sr3highx2 |
| |
| z1 -= alpha32 |
| |
| z0 -= alpha0 |
| |
| h5 += z3 |
| |
| h3 += z2 |
| |
| h1 += z1 |
| |
| h0 += z0 |
| |
| if l >= 16 { |
| goto multiplyaddatleast16bytes |
| } |
| |
| multiplyaddatmost15bytes: |
| |
| y7 = h7 + alpha130 |
| |
| y6 = h6 + alpha130 |
| |
| y1 = h1 + alpha32 |
| |
| y0 = h0 + alpha32 |
| |
| y7 -= alpha130 |
| |
| y6 -= alpha130 |
| |
| y1 -= alpha32 |
| |
| y0 -= alpha32 |
| |
| y5 = h5 + alpha96 |
| |
| y4 = h4 + alpha96 |
| |
| x7 = h7 - y7 |
| y7 *= scale |
| |
| x6 = h6 - y6 |
| y6 *= scale |
| |
| x1 = h1 - y1 |
| |
| x0 = h0 - y0 |
| |
| y5 -= alpha96 |
| |
| y4 -= alpha96 |
| |
| x1 += y7 |
| |
| x0 += y6 |
| |
| x7 += y5 |
| |
| x6 += y4 |
| |
| y3 = h3 + alpha64 |
| |
| y2 = h2 + alpha64 |
| |
| x0 += x1 |
| |
| x6 += x7 |
| |
| y3 -= alpha64 |
| r3low = r3low_stack |
| |
| y2 -= alpha64 |
| r0low = r0low_stack |
| |
| x5 = h5 - y5 |
| r3lowx0 = r3low * x0 |
| r3high = r3high_stack |
| |
| x4 = h4 - y4 |
| r0lowx6 = r0low * x6 |
| r0high = r0high_stack |
| |
| x3 = h3 - y3 |
| r3highx0 = r3high * x0 |
| sr1low = sr1low_stack |
| |
| x2 = h2 - y2 |
| r0highx6 = r0high * x6 |
| sr1high = sr1high_stack |
| |
| x5 += y3 |
| r0lowx0 = r0low * x0 |
| r1low = r1low_stack |
| |
| h6 = r3lowx0 + r0lowx6 |
| sr1lowx6 = sr1low * x6 |
| r1high = r1high_stack |
| |
| x4 += y2 |
| r0highx0 = r0high * x0 |
| sr2low = sr2low_stack |
| |
| h7 = r3highx0 + r0highx6 |
| sr1highx6 = sr1high * x6 |
| sr2high = sr2high_stack |
| |
| x3 += y1 |
| r1lowx0 = r1low * x0 |
| r2low = r2low_stack |
| |
| h0 = r0lowx0 + sr1lowx6 |
| sr2lowx6 = sr2low * x6 |
| r2high = r2high_stack |
| |
| x2 += y0 |
| r1highx0 = r1high * x0 |
| sr3low = sr3low_stack |
| |
| h1 = r0highx0 + sr1highx6 |
| sr2highx6 = sr2high * x6 |
| sr3high = sr3high_stack |
| |
| x4 += x5 |
| r2lowx0 = r2low * x0 |
| |
| h2 = r1lowx0 + sr2lowx6 |
| sr3lowx6 = sr3low * x6 |
| |
| x2 += x3 |
| r2highx0 = r2high * x0 |
| |
| h3 = r1highx0 + sr2highx6 |
| sr3highx6 = sr3high * x6 |
| |
| r1highx4 = r1high * x4 |
| |
| h4 = r2lowx0 + sr3lowx6 |
| r1lowx4 = r1low * x4 |
| |
| r0highx4 = r0high * x4 |
| |
| h5 = r2highx0 + sr3highx6 |
| r0lowx4 = r0low * x4 |
| |
| h7 += r1highx4 |
| sr3highx4 = sr3high * x4 |
| |
| h6 += r1lowx4 |
| sr3lowx4 = sr3low * x4 |
| |
| h5 += r0highx4 |
| sr2highx4 = sr2high * x4 |
| |
| h4 += r0lowx4 |
| sr2lowx4 = sr2low * x4 |
| |
| h3 += sr3highx4 |
| r0lowx2 = r0low * x2 |
| |
| h2 += sr3lowx4 |
| r0highx2 = r0high * x2 |
| |
| h1 += sr2highx4 |
| r1lowx2 = r1low * x2 |
| |
| h0 += sr2lowx4 |
| r1highx2 = r1high * x2 |
| |
| h2 += r0lowx2 |
| r2lowx2 = r2low * x2 |
| |
| h3 += r0highx2 |
| r2highx2 = r2high * x2 |
| |
| h4 += r1lowx2 |
| sr3lowx2 = sr3low * x2 |
| |
| h5 += r1highx2 |
| sr3highx2 = sr3high * x2 |
| |
| h6 += r2lowx2 |
| |
| h7 += r2highx2 |
| |
| h0 += sr3lowx2 |
| |
| h1 += sr3highx2 |
| |
| addatmost15bytes: |
| |
| if l == 0 { |
| goto nomorebytes |
| } |
| |
| lbelow2 = l - 2 |
| |
| lbelow3 = l - 3 |
| |
| lbelow2 >>= 31 |
| lbelow4 = l - 4 |
| |
| m00 = uint32(m[p+0]) |
| lbelow3 >>= 31 |
| p += lbelow2 |
| |
| m01 = uint32(m[p+1]) |
| lbelow4 >>= 31 |
| p += lbelow3 |
| |
| m02 = uint32(m[p+2]) |
| p += lbelow4 |
| m0 = 2151 |
| |
| m03 = uint32(m[p+3]) |
| m0 <<= 51 |
| m1 = 2215 |
| |
| m0 += int64(m00) |
| m01 &^= uint32(lbelow2) |
| |
| m02 &^= uint32(lbelow3) |
| m01 -= uint32(lbelow2) |
| |
| m01 <<= 8 |
| m03 &^= uint32(lbelow4) |
| |
| m0 += int64(m01) |
| lbelow2 -= lbelow3 |
| |
| m02 += uint32(lbelow2) |
| lbelow3 -= lbelow4 |
| |
| m02 <<= 16 |
| m03 += uint32(lbelow3) |
| |
| m03 <<= 24 |
| m0 += int64(m02) |
| |
| m0 += int64(m03) |
| lbelow5 = l - 5 |
| |
| lbelow6 = l - 6 |
| lbelow7 = l - 7 |
| |
| lbelow5 >>= 31 |
| lbelow8 = l - 8 |
| |
| lbelow6 >>= 31 |
| p += lbelow5 |
| |
| m10 = uint32(m[p+4]) |
| lbelow7 >>= 31 |
| p += lbelow6 |
| |
| m11 = uint32(m[p+5]) |
| lbelow8 >>= 31 |
| p += lbelow7 |
| |
| m12 = uint32(m[p+6]) |
| m1 <<= 51 |
| p += lbelow8 |
| |
| m13 = uint32(m[p+7]) |
| m10 &^= uint32(lbelow5) |
| lbelow4 -= lbelow5 |
| |
| m10 += uint32(lbelow4) |
| lbelow5 -= lbelow6 |
| |
| m11 &^= uint32(lbelow6) |
| m11 += uint32(lbelow5) |
| |
| m11 <<= 8 |
| m1 += int64(m10) |
| |
| m1 += int64(m11) |
| m12 &^= uint32(lbelow7) |
| |
| lbelow6 -= lbelow7 |
| m13 &^= uint32(lbelow8) |
| |
| m12 += uint32(lbelow6) |
| lbelow7 -= lbelow8 |
| |
| m12 <<= 16 |
| m13 += uint32(lbelow7) |
| |
| m13 <<= 24 |
| m1 += int64(m12) |
| |
| m1 += int64(m13) |
| m2 = 2279 |
| |
| lbelow9 = l - 9 |
| m3 = 2343 |
| |
| lbelow10 = l - 10 |
| lbelow11 = l - 11 |
| |
| lbelow9 >>= 31 |
| lbelow12 = l - 12 |
| |
| lbelow10 >>= 31 |
| p += lbelow9 |
| |
| m20 = uint32(m[p+8]) |
| lbelow11 >>= 31 |
| p += lbelow10 |
| |
| m21 = uint32(m[p+9]) |
| lbelow12 >>= 31 |
| p += lbelow11 |
| |
| m22 = uint32(m[p+10]) |
| m2 <<= 51 |
| p += lbelow12 |
| |
| m23 = uint32(m[p+11]) |
| m20 &^= uint32(lbelow9) |
| lbelow8 -= lbelow9 |
| |
| m20 += uint32(lbelow8) |
| lbelow9 -= lbelow10 |
| |
| m21 &^= uint32(lbelow10) |
| m21 += uint32(lbelow9) |
| |
| m21 <<= 8 |
| m2 += int64(m20) |
| |
| m2 += int64(m21) |
| m22 &^= uint32(lbelow11) |
| |
| lbelow10 -= lbelow11 |
| m23 &^= uint32(lbelow12) |
| |
| m22 += uint32(lbelow10) |
| lbelow11 -= lbelow12 |
| |
| m22 <<= 16 |
| m23 += uint32(lbelow11) |
| |
| m23 <<= 24 |
| m2 += int64(m22) |
| |
| m3 <<= 51 |
| lbelow13 = l - 13 |
| |
| lbelow13 >>= 31 |
| lbelow14 = l - 14 |
| |
| lbelow14 >>= 31 |
| p += lbelow13 |
| lbelow15 = l - 15 |
| |
| m30 = uint32(m[p+12]) |
| lbelow15 >>= 31 |
| p += lbelow14 |
| |
| m31 = uint32(m[p+13]) |
| p += lbelow15 |
| m2 += int64(m23) |
| |
| m32 = uint32(m[p+14]) |
| m30 &^= uint32(lbelow13) |
| lbelow12 -= lbelow13 |
| |
| m30 += uint32(lbelow12) |
| lbelow13 -= lbelow14 |
| |
| m3 += int64(m30) |
| m31 &^= uint32(lbelow14) |
| |
| m31 += uint32(lbelow13) |
| m32 &^= uint32(lbelow15) |
| |
| m31 <<= 8 |
| lbelow14 -= lbelow15 |
| |
| m3 += int64(m31) |
| m32 += uint32(lbelow14) |
| d0 = m0 |
| |
| m32 <<= 16 |
| m33 = uint64(lbelow15 + 1) |
| d1 = m1 |
| |
| m33 <<= 24 |
| m3 += int64(m32) |
| d2 = m2 |
| |
| m3 += int64(m33) |
| d3 = m3 |
| |
| z3 = math.Float64frombits(uint64(d3)) |
| |
| z2 = math.Float64frombits(uint64(d2)) |
| |
| z1 = math.Float64frombits(uint64(d1)) |
| |
| z0 = math.Float64frombits(uint64(d0)) |
| |
| z3 -= alpha96 |
| |
| z2 -= alpha64 |
| |
| z1 -= alpha32 |
| |
| z0 -= alpha0 |
| |
| h5 += z3 |
| |
| h3 += z2 |
| |
| h1 += z1 |
| |
| h0 += z0 |
| |
| y7 = h7 + alpha130 |
| |
| y6 = h6 + alpha130 |
| |
| y1 = h1 + alpha32 |
| |
| y0 = h0 + alpha32 |
| |
| y7 -= alpha130 |
| |
| y6 -= alpha130 |
| |
| y1 -= alpha32 |
| |
| y0 -= alpha32 |
| |
| y5 = h5 + alpha96 |
| |
| y4 = h4 + alpha96 |
| |
| x7 = h7 - y7 |
| y7 *= scale |
| |
| x6 = h6 - y6 |
| y6 *= scale |
| |
| x1 = h1 - y1 |
| |
| x0 = h0 - y0 |
| |
| y5 -= alpha96 |
| |
| y4 -= alpha96 |
| |
| x1 += y7 |
| |
| x0 += y6 |
| |
| x7 += y5 |
| |
| x6 += y4 |
| |
| y3 = h3 + alpha64 |
| |
| y2 = h2 + alpha64 |
| |
| x0 += x1 |
| |
| x6 += x7 |
| |
| y3 -= alpha64 |
| r3low = r3low_stack |
| |
| y2 -= alpha64 |
| r0low = r0low_stack |
| |
| x5 = h5 - y5 |
| r3lowx0 = r3low * x0 |
| r3high = r3high_stack |
| |
| x4 = h4 - y4 |
| r0lowx6 = r0low * x6 |
| r0high = r0high_stack |
| |
| x3 = h3 - y3 |
| r3highx0 = r3high * x0 |
| sr1low = sr1low_stack |
| |
| x2 = h2 - y2 |
| r0highx6 = r0high * x6 |
| sr1high = sr1high_stack |
| |
| x5 += y3 |
| r0lowx0 = r0low * x0 |
| r1low = r1low_stack |
| |
| h6 = r3lowx0 + r0lowx6 |
| sr1lowx6 = sr1low * x6 |
| r1high = r1high_stack |
| |
| x4 += y2 |
| r0highx0 = r0high * x0 |
| sr2low = sr2low_stack |
| |
| h7 = r3highx0 + r0highx6 |
| sr1highx6 = sr1high * x6 |
| sr2high = sr2high_stack |
| |
| x3 += y1 |
| r1lowx0 = r1low * x0 |
| r2low = r2low_stack |
| |
| h0 = r0lowx0 + sr1lowx6 |
| sr2lowx6 = sr2low * x6 |
| r2high = r2high_stack |
| |
| x2 += y0 |
| r1highx0 = r1high * x0 |
| sr3low = sr3low_stack |
| |
| h1 = r0highx0 + sr1highx6 |
| sr2highx6 = sr2high * x6 |
| sr3high = sr3high_stack |
| |
| x4 += x5 |
| r2lowx0 = r2low * x0 |
| |
| h2 = r1lowx0 + sr2lowx6 |
| sr3lowx6 = sr3low * x6 |
| |
| x2 += x3 |
| r2highx0 = r2high * x0 |
| |
| h3 = r1highx0 + sr2highx6 |
| sr3highx6 = sr3high * x6 |
| |
| r1highx4 = r1high * x4 |
| |
| h4 = r2lowx0 + sr3lowx6 |
| r1lowx4 = r1low * x4 |
| |
| r0highx4 = r0high * x4 |
| |
| h5 = r2highx0 + sr3highx6 |
| r0lowx4 = r0low * x4 |
| |
| h7 += r1highx4 |
| sr3highx4 = sr3high * x4 |
| |
| h6 += r1lowx4 |
| sr3lowx4 = sr3low * x4 |
| |
| h5 += r0highx4 |
| sr2highx4 = sr2high * x4 |
| |
| h4 += r0lowx4 |
| sr2lowx4 = sr2low * x4 |
| |
| h3 += sr3highx4 |
| r0lowx2 = r0low * x2 |
| |
| h2 += sr3lowx4 |
| r0highx2 = r0high * x2 |
| |
| h1 += sr2highx4 |
| r1lowx2 = r1low * x2 |
| |
| h0 += sr2lowx4 |
| r1highx2 = r1high * x2 |
| |
| h2 += r0lowx2 |
| r2lowx2 = r2low * x2 |
| |
| h3 += r0highx2 |
| r2highx2 = r2high * x2 |
| |
| h4 += r1lowx2 |
| sr3lowx2 = sr3low * x2 |
| |
| h5 += r1highx2 |
| sr3highx2 = sr3high * x2 |
| |
| h6 += r2lowx2 |
| |
| h7 += r2highx2 |
| |
| h0 += sr3lowx2 |
| |
| h1 += sr3highx2 |
| |
| nomorebytes: |
| |
| y7 = h7 + alpha130 |
| |
| y0 = h0 + alpha32 |
| |
| y1 = h1 + alpha32 |
| |
| y2 = h2 + alpha64 |
| |
| y7 -= alpha130 |
| |
| y3 = h3 + alpha64 |
| |
| y4 = h4 + alpha96 |
| |
| y5 = h5 + alpha96 |
| |
| x7 = h7 - y7 |
| y7 *= scale |
| |
| y0 -= alpha32 |
| |
| y1 -= alpha32 |
| |
| y2 -= alpha64 |
| |
| h6 += x7 |
| |
| y3 -= alpha64 |
| |
| y4 -= alpha96 |
| |
| y5 -= alpha96 |
| |
| y6 = h6 + alpha130 |
| |
| x0 = h0 - y0 |
| |
| x1 = h1 - y1 |
| |
| x2 = h2 - y2 |
| |
| y6 -= alpha130 |
| |
| x0 += y7 |
| |
| x3 = h3 - y3 |
| |
| x4 = h4 - y4 |
| |
| x5 = h5 - y5 |
| |
| x6 = h6 - y6 |
| |
| y6 *= scale |
| |
| x2 += y0 |
| |
| x3 += y1 |
| |
| x4 += y2 |
| |
| x0 += y6 |
| |
| x5 += y3 |
| |
| x6 += y4 |
| |
| x2 += x3 |
| |
| x0 += x1 |
| |
| x4 += x5 |
| |
| x6 += y5 |
| |
| x2 += offset1 |
| d1 = int64(math.Float64bits(x2)) |
| |
| x0 += offset0 |
| d0 = int64(math.Float64bits(x0)) |
| |
| x4 += offset2 |
| d2 = int64(math.Float64bits(x4)) |
| |
| x6 += offset3 |
| d3 = int64(math.Float64bits(x6)) |
| |
| f0 = uint64(d0) |
| |
| f1 = uint64(d1) |
| bits32 = math.MaxUint64 |
| |
| f2 = uint64(d2) |
| bits32 >>= 32 |
| |
| f3 = uint64(d3) |
| f = f0 >> 32 |
| |
| f0 &= bits32 |
| f &= 255 |
| |
| f1 += f |
| g0 = f0 + 5 |
| |
| g = g0 >> 32 |
| g0 &= bits32 |
| |
| f = f1 >> 32 |
| f1 &= bits32 |
| |
| f &= 255 |
| g1 = f1 + g |
| |
| g = g1 >> 32 |
| f2 += f |
| |
| f = f2 >> 32 |
| g1 &= bits32 |
| |
| f2 &= bits32 |
| f &= 255 |
| |
| f3 += f |
| g2 = f2 + g |
| |
| g = g2 >> 32 |
| g2 &= bits32 |
| |
| f4 = f3 >> 32 |
| f3 &= bits32 |
| |
| f4 &= 255 |
| g3 = f3 + g |
| |
| g = g3 >> 32 |
| g3 &= bits32 |
| |
| g4 = f4 + g |
| |
| g4 = g4 - 4 |
| s00 = uint32(s[0]) |
| |
| f = uint64(int64(g4) >> 63) |
| s01 = uint32(s[1]) |
| |
| f0 &= f |
| g0 &^= f |
| s02 = uint32(s[2]) |
| |
| f1 &= f |
| f0 |= g0 |
| s03 = uint32(s[3]) |
| |
| g1 &^= f |
| f2 &= f |
| s10 = uint32(s[4]) |
| |
| f3 &= f |
| g2 &^= f |
| s11 = uint32(s[5]) |
| |
| g3 &^= f |
| f1 |= g1 |
| s12 = uint32(s[6]) |
| |
| f2 |= g2 |
| f3 |= g3 |
| s13 = uint32(s[7]) |
| |
| s01 <<= 8 |
| f0 += uint64(s00) |
| s20 = uint32(s[8]) |
| |
| s02 <<= 16 |
| f0 += uint64(s01) |
| s21 = uint32(s[9]) |
| |
| s03 <<= 24 |
| f0 += uint64(s02) |
| s22 = uint32(s[10]) |
| |
| s11 <<= 8 |
| f1 += uint64(s10) |
| s23 = uint32(s[11]) |
| |
| s12 <<= 16 |
| f1 += uint64(s11) |
| s30 = uint32(s[12]) |
| |
| s13 <<= 24 |
| f1 += uint64(s12) |
| s31 = uint32(s[13]) |
| |
| f0 += uint64(s03) |
| f1 += uint64(s13) |
| s32 = uint32(s[14]) |
| |
| s21 <<= 8 |
| f2 += uint64(s20) |
| s33 = uint32(s[15]) |
| |
| s22 <<= 16 |
| f2 += uint64(s21) |
| |
| s23 <<= 24 |
| f2 += uint64(s22) |
| |
| s31 <<= 8 |
| f3 += uint64(s30) |
| |
| s32 <<= 16 |
| f3 += uint64(s31) |
| |
| s33 <<= 24 |
| f3 += uint64(s32) |
| |
| f2 += uint64(s23) |
| f3 += uint64(s33) |
| |
| out[0] = byte(f0) |
| f0 >>= 8 |
| out[1] = byte(f0) |
| f0 >>= 8 |
| out[2] = byte(f0) |
| f0 >>= 8 |
| out[3] = byte(f0) |
| f0 >>= 8 |
| f1 += f0 |
| |
| out[4] = byte(f1) |
| f1 >>= 8 |
| out[5] = byte(f1) |
| f1 >>= 8 |
| out[6] = byte(f1) |
| f1 >>= 8 |
| out[7] = byte(f1) |
| f1 >>= 8 |
| f2 += f1 |
| |
| out[8] = byte(f2) |
| f2 >>= 8 |
| out[9] = byte(f2) |
| f2 >>= 8 |
| out[10] = byte(f2) |
| f2 >>= 8 |
| out[11] = byte(f2) |
| f2 >>= 8 |
| f3 += f2 |
| |
| out[12] = byte(f3) |
| f3 >>= 8 |
| out[13] = byte(f3) |
| f3 >>= 8 |
| out[14] = byte(f3) |
| f3 >>= 8 |
| out[15] = byte(f3) |
| } |
