1// Copyright 2009 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// Package adler32 implements the Adler-32 checksum.
6//
7// It is defined in RFC 1950:
8//
9//	Adler-32 is composed of two sums accumulated per byte: s1 is
10//	the sum of all bytes, s2 is the sum of all s1 values. Both sums
11//	are done modulo 65521. s1 is initialized to 1, s2 to zero.  The
12//	Adler-32 checksum is stored as s2*65536 + s1 in most-
13//	significant-byte first (network) order.
14package adler32
15
16import (
17	"errors"
18	"hash"
19	"internal/byteorder"
20)
21
22const (
23	// mod is the largest prime that is less than 65536.
24	mod = 65521
25	// nmax is the largest n such that
26	// 255 * n * (n+1) / 2 + (n+1) * (mod-1) <= 2^32-1.
27	// It is mentioned in RFC 1950 (search for "5552").
28	nmax = 5552
29)
30
31// The size of an Adler-32 checksum in bytes.
32const Size = 4
33
34// digest represents the partial evaluation of a checksum.
35// The low 16 bits are s1, the high 16 bits are s2.
36type digest uint32
37
38func (d *digest) Reset() { *d = 1 }
39
40// New returns a new hash.Hash32 computing the Adler-32 checksum. Its
41// Sum method will lay the value out in big-endian byte order. The
42// returned Hash32 also implements [encoding.BinaryMarshaler] and
43// [encoding.BinaryUnmarshaler] to marshal and unmarshal the internal
44// state of the hash.
45func New() hash.Hash32 {
46	d := new(digest)
47	d.Reset()
48	return d
49}
50
51func (d *digest) Size() int { return Size }
52
53func (d *digest) BlockSize() int { return 4 }
54
55const (
56	magic         = "adl\x01"
57	marshaledSize = len(magic) + 4
58)
59
60func (d *digest) MarshalBinary() ([]byte, error) {
61	b := make([]byte, 0, marshaledSize)
62	b = append(b, magic...)
63	b = byteorder.BeAppendUint32(b, uint32(*d))
64	return b, nil
65}
66
67func (d *digest) UnmarshalBinary(b []byte) error {
68	if len(b) < len(magic) || string(b[:len(magic)]) != magic {
69		return errors.New("hash/adler32: invalid hash state identifier")
70	}
71	if len(b) != marshaledSize {
72		return errors.New("hash/adler32: invalid hash state size")
73	}
74	*d = digest(byteorder.BeUint32(b[len(magic):]))
75	return nil
76}
77
78// Add p to the running checksum d.
79func update(d digest, p []byte) digest {
80	s1, s2 := uint32(d&0xffff), uint32(d>>16)
81	for len(p) > 0 {
82		var q []byte
83		if len(p) > nmax {
84			p, q = p[:nmax], p[nmax:]
85		}
86		for len(p) >= 4 {
87			s1 += uint32(p[0])
88			s2 += s1
89			s1 += uint32(p[1])
90			s2 += s1
91			s1 += uint32(p[2])
92			s2 += s1
93			s1 += uint32(p[3])
94			s2 += s1
95			p = p[4:]
96		}
97		for _, x := range p {
98			s1 += uint32(x)
99			s2 += s1
100		}
101		s1 %= mod
102		s2 %= mod
103		p = q
104	}
105	return digest(s2<<16 | s1)
106}
107
108func (d *digest) Write(p []byte) (nn int, err error) {
109	*d = update(*d, p)
110	return len(p), nil
111}
112
113func (d *digest) Sum32() uint32 { return uint32(*d) }
114
115func (d *digest) Sum(in []byte) []byte {
116	s := uint32(*d)
117	return append(in, byte(s>>24), byte(s>>16), byte(s>>8), byte(s))
118}
119
120// Checksum returns the Adler-32 checksum of data.
121func Checksum(data []byte) uint32 { return uint32(update(1, data)) }
122