mirror of
https://github.com/cheat/cheat.git
synced 2024-11-25 15:31:36 +01:00
80c91cbdee
Integrate `go-git` into the application, and use it to `git clone` cheatsheets when the installer runs. Previously, the installer required that `git` be installed on the system `PATH`, so this change has to big advantages: 1. It removes that system dependency on `git` 2. It paves the way for implementing the `--update` command Additionally, `cheat` now performs a `--depth=1` clone when installing cheatsheets, which should at least somewhat improve installation times (especially on slow network connections).
81 lines
1.7 KiB
Go
81 lines
1.7 KiB
Go
// Package ecdsa implements ECDSA signature, suitable for OpenPGP,
|
|
// as specified in RFC 6637, section 5.
|
|
package ecdsa
|
|
|
|
import (
|
|
"errors"
|
|
"github.com/ProtonMail/go-crypto/openpgp/internal/ecc"
|
|
"io"
|
|
"math/big"
|
|
)
|
|
|
|
type PublicKey struct {
|
|
X, Y *big.Int
|
|
curve ecc.ECDSACurve
|
|
}
|
|
|
|
type PrivateKey struct {
|
|
PublicKey
|
|
D *big.Int
|
|
}
|
|
|
|
func NewPublicKey(curve ecc.ECDSACurve) *PublicKey {
|
|
return &PublicKey{
|
|
curve: curve,
|
|
}
|
|
}
|
|
|
|
func NewPrivateKey(key PublicKey) *PrivateKey {
|
|
return &PrivateKey{
|
|
PublicKey: key,
|
|
}
|
|
}
|
|
|
|
func (pk *PublicKey) GetCurve() ecc.ECDSACurve {
|
|
return pk.curve
|
|
}
|
|
|
|
func (pk *PublicKey) MarshalPoint() []byte {
|
|
return pk.curve.MarshalIntegerPoint(pk.X, pk.Y)
|
|
}
|
|
|
|
func (pk *PublicKey) UnmarshalPoint(p []byte) error {
|
|
pk.X, pk.Y = pk.curve.UnmarshalIntegerPoint(p)
|
|
if pk.X == nil {
|
|
return errors.New("ecdsa: failed to parse EC point")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (sk *PrivateKey) MarshalIntegerSecret() []byte {
|
|
return sk.curve.MarshalIntegerSecret(sk.D)
|
|
}
|
|
|
|
func (sk *PrivateKey) UnmarshalIntegerSecret(d []byte) error {
|
|
sk.D = sk.curve.UnmarshalIntegerSecret(d)
|
|
|
|
if sk.D == nil {
|
|
return errors.New("ecdsa: failed to parse scalar")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func GenerateKey(rand io.Reader, c ecc.ECDSACurve) (priv *PrivateKey, err error) {
|
|
priv = new(PrivateKey)
|
|
priv.PublicKey.curve = c
|
|
priv.PublicKey.X, priv.PublicKey.Y, priv.D, err = c.GenerateECDSA(rand)
|
|
return
|
|
}
|
|
|
|
func Sign(rand io.Reader, priv *PrivateKey, hash []byte) (r, s *big.Int, err error) {
|
|
return priv.PublicKey.curve.Sign(rand, priv.X, priv.Y, priv.D, hash)
|
|
}
|
|
|
|
func Verify(pub *PublicKey, hash []byte, r, s *big.Int) bool {
|
|
return pub.curve.Verify(pub.X, pub.Y, hash, r, s)
|
|
}
|
|
|
|
func Validate(priv *PrivateKey) error {
|
|
return priv.curve.ValidateECDSA(priv.X, priv.Y, priv.D.Bytes())
|
|
}
|