1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75
76. 76
77. 77
78. 78
79. 79
80. 80
81. 81
82. 82
83. 83
84. 84
85. 85
86. 86
87. 87
88. 88
89. 89
90. 90
91. 91

// Copyright 2017 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.

package encoding

import (
	"io"
	"math/big"
	"math/bits"
)

// An MPI is used to store the contents of a big integer, along with the bit
// length that was specified in the original input. This allows the MPI to be
// reserialized exactly.
type MPI struct {
	bytes     []byte
	bitLength uint16
}

// NewMPI returns a MPI initialized with bytes.
func NewMPI(bytes []byte) *MPI {
	for len(bytes) != 0 && bytes[0] == 0 {
		bytes = bytes[1:]
	}
	if len(bytes) == 0 {
		bitLength := uint16(0)
		return &MPI{bytes, bitLength}
	}
	bitLength := 8*uint16(len(bytes)-1) + uint16(bits.Len8(bytes[0]))
	return &MPI{bytes, bitLength}
}

// Bytes returns the decoded data.
func (m *MPI) Bytes() []byte {
	return m.bytes
}

// BitLength is the size in bits of the decoded data.
func (m *MPI) BitLength() uint16 {
	return m.bitLength
}

// EncodedBytes returns the encoded data.
func (m *MPI) EncodedBytes() []byte {
	return append([]byte{byte(m.bitLength >> 8), byte(m.bitLength)}, m.bytes...)
}

// EncodedLength is the size in bytes of the encoded data.
func (m *MPI) EncodedLength() uint16 {
	return uint16(2 + len(m.bytes))
}

// ReadFrom reads into m the next MPI from r.
func (m *MPI) ReadFrom(r io.Reader) (int64, error) {
	var buf [2]byte
	n, err := io.ReadFull(r, buf[0:])
	if err != nil {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
		return int64(n), err
	}

	m.bitLength = uint16(buf[0])<<8 | uint16(buf[1])
	m.bytes = make([]byte, (int(m.bitLength)+7)/8)

	nn, err := io.ReadFull(r, m.bytes)
	if err == io.EOF {
		err = io.ErrUnexpectedEOF
	}

	// remove leading zero bytes from malformed GnuPG encoded MPIs:
	// https://bugs.gnupg.org/gnupg/issue1853
	// for _, b := range m.bytes {
	// 	if b != 0 {
	// 		break
	// 	}
	// 	m.bytes = m.bytes[1:]
	// 	m.bitLength -= 8
	// }

	return int64(n) + int64(nn), err
}

// SetBig initializes m with the bits from n.
func (m *MPI) SetBig(n *big.Int) *MPI {
	m.bytes = n.Bytes()
	m.bitLength = uint16(n.BitLen())
	return m
}