1007 lines
16 KiB
Markdown
1007 lines
16 KiB
Markdown
# crypto
|
|
--
|
|
import "github.com/go-i2p/go-i2p/lib/crypto"
|
|
|
|
|
|
|
|
package for i2p specific crpytography
|
|
|
|
## Usage
|
|
|
|
```go
|
|
const (
|
|
IPAD = byte(0x36)
|
|
OPAD = byte(0x5C)
|
|
)
|
|
```
|
|
|
|
```go
|
|
var (
|
|
Ed25519EncryptTooBig = oops.Errorf("failed to encrypt data, too big for Ed25519")
|
|
ErrInvalidPublicKeySize = oops.Errorf("failed to verify: invalid ed25519 public key size")
|
|
)
|
|
```
|
|
|
|
```go
|
|
var (
|
|
ElgDecryptFail = oops.Errorf("failed to decrypt elgamal encrypted data")
|
|
ElgEncryptTooBig = oops.Errorf("failed to encrypt data, too big for elgamal")
|
|
)
|
|
```
|
|
|
|
```go
|
|
var (
|
|
ErrBadSignatureSize = oops.Errorf("bad signature size")
|
|
ErrInvalidKeyFormat = oops.Errorf("invalid key format")
|
|
ErrInvalidSignature = oops.Errorf("invalid signature")
|
|
)
|
|
```
|
|
|
|
```go
|
|
var Curve25519EncryptTooBig = oops.Errorf("failed to encrypt data, too big for Curve25519")
|
|
```
|
|
|
|
```go
|
|
var SHA256 = sha256.Sum256
|
|
```
|
|
|
|
#### func ElgamalGenerate
|
|
|
|
```go
|
|
func ElgamalGenerate(priv *elgamal.PrivateKey, rand io.Reader) (err error)
|
|
```
|
|
generate an elgamal key pair
|
|
|
|
#### type AESSymmetricDecrypter
|
|
|
|
```go
|
|
type AESSymmetricDecrypter struct {
|
|
Key []byte
|
|
IV []byte
|
|
}
|
|
```
|
|
|
|
AESSymmetricDecrypter implements the Decrypter interface using AES
|
|
|
|
#### func (*AESSymmetricDecrypter) Decrypt
|
|
|
|
```go
|
|
func (d *AESSymmetricDecrypter) Decrypt(data []byte) ([]byte, error)
|
|
```
|
|
Decrypt decrypts data using AES-CBC with PKCS#7 padding
|
|
|
|
#### func (*AESSymmetricDecrypter) DecryptNoPadding
|
|
|
|
```go
|
|
func (d *AESSymmetricDecrypter) DecryptNoPadding(data []byte) ([]byte, error)
|
|
```
|
|
DecryptNoPadding decrypts data using AES-CBC without padding
|
|
|
|
#### type AESSymmetricEncrypter
|
|
|
|
```go
|
|
type AESSymmetricEncrypter struct {
|
|
Key []byte
|
|
IV []byte
|
|
}
|
|
```
|
|
|
|
AESSymmetricEncrypter implements the Encrypter interface using AES
|
|
|
|
#### func (*AESSymmetricEncrypter) Encrypt
|
|
|
|
```go
|
|
func (e *AESSymmetricEncrypter) Encrypt(data []byte) ([]byte, error)
|
|
```
|
|
Encrypt encrypts data using AES-CBC with PKCS#7 padding
|
|
|
|
#### func (*AESSymmetricEncrypter) EncryptNoPadding
|
|
|
|
```go
|
|
func (e *AESSymmetricEncrypter) EncryptNoPadding(data []byte) ([]byte, error)
|
|
```
|
|
EncryptNoPadding encrypts data using AES-CBC without padding
|
|
|
|
#### type AESSymmetricKey
|
|
|
|
```go
|
|
type AESSymmetricKey struct {
|
|
Key []byte // AES key (must be 16, 24, or 32 bytes for AES-128, AES-192, AES-256)
|
|
IV []byte // Initialization Vector (must be 16 bytes for AES)
|
|
}
|
|
```
|
|
|
|
AESSymmetricKey represents a symmetric key for AES encryption/decryption
|
|
|
|
#### func (*AESSymmetricKey) Len
|
|
|
|
```go
|
|
func (k *AESSymmetricKey) Len() int
|
|
```
|
|
Len returns the length of the key
|
|
|
|
#### func (*AESSymmetricKey) NewDecrypter
|
|
|
|
```go
|
|
func (k *AESSymmetricKey) NewDecrypter() (Decrypter, error)
|
|
```
|
|
NewDecrypter creates a new AESSymmetricDecrypter
|
|
|
|
#### func (*AESSymmetricKey) NewEncrypter
|
|
|
|
```go
|
|
func (k *AESSymmetricKey) NewEncrypter() (Encrypter, error)
|
|
```
|
|
NewEncrypter creates a new AESSymmetricEncrypter
|
|
|
|
#### type Curve25519Encryption
|
|
|
|
```go
|
|
type Curve25519Encryption struct {
|
|
}
|
|
```
|
|
|
|
|
|
#### func (*Curve25519Encryption) Encrypt
|
|
|
|
```go
|
|
func (curve25519 *Curve25519Encryption) Encrypt(data []byte) (enc []byte, err error)
|
|
```
|
|
|
|
#### func (*Curve25519Encryption) EncryptPadding
|
|
|
|
```go
|
|
func (curve25519 *Curve25519Encryption) EncryptPadding(data []byte, zeroPadding bool) (encrypted []byte, err error)
|
|
```
|
|
|
|
#### type Curve25519PrivateKey
|
|
|
|
```go
|
|
type Curve25519PrivateKey curve25519.PrivateKey
|
|
```
|
|
|
|
|
|
#### type Curve25519PublicKey
|
|
|
|
```go
|
|
type Curve25519PublicKey []byte
|
|
```
|
|
|
|
|
|
#### func (Curve25519PublicKey) Len
|
|
|
|
```go
|
|
func (k Curve25519PublicKey) Len() int
|
|
```
|
|
|
|
#### func (Curve25519PublicKey) NewEncrypter
|
|
|
|
```go
|
|
func (elg Curve25519PublicKey) NewEncrypter() (enc Encrypter, err error)
|
|
```
|
|
|
|
#### func (Curve25519PublicKey) NewVerifier
|
|
|
|
```go
|
|
func (k Curve25519PublicKey) NewVerifier() (v Verifier, err error)
|
|
```
|
|
|
|
#### type Curve25519Signer
|
|
|
|
```go
|
|
type Curve25519Signer struct {
|
|
}
|
|
```
|
|
|
|
|
|
#### func (*Curve25519Signer) Sign
|
|
|
|
```go
|
|
func (s *Curve25519Signer) Sign(data []byte) (sig []byte, err error)
|
|
```
|
|
|
|
#### func (*Curve25519Signer) SignHash
|
|
|
|
```go
|
|
func (s *Curve25519Signer) SignHash(h []byte) (sig []byte, err error)
|
|
```
|
|
|
|
#### type Curve25519Verifier
|
|
|
|
```go
|
|
type Curve25519Verifier struct {
|
|
}
|
|
```
|
|
|
|
|
|
#### func (*Curve25519Verifier) Verify
|
|
|
|
```go
|
|
func (v *Curve25519Verifier) Verify(data, sig []byte) (err error)
|
|
```
|
|
|
|
#### func (*Curve25519Verifier) VerifyHash
|
|
|
|
```go
|
|
func (v *Curve25519Verifier) VerifyHash(h, sig []byte) (err error)
|
|
```
|
|
|
|
#### type DSAPrivateKey
|
|
|
|
```go
|
|
type DSAPrivateKey [20]byte
|
|
```
|
|
|
|
|
|
#### func (DSAPrivateKey) Generate
|
|
|
|
```go
|
|
func (k DSAPrivateKey) Generate() (s DSAPrivateKey, err error)
|
|
```
|
|
|
|
#### func (DSAPrivateKey) Len
|
|
|
|
```go
|
|
func (k DSAPrivateKey) Len() int
|
|
```
|
|
|
|
#### func (DSAPrivateKey) NewSigner
|
|
|
|
```go
|
|
func (k DSAPrivateKey) NewSigner() (s Signer, err error)
|
|
```
|
|
create a new dsa signer
|
|
|
|
#### func (DSAPrivateKey) Public
|
|
|
|
```go
|
|
func (k DSAPrivateKey) Public() (pk DSAPublicKey, err error)
|
|
```
|
|
|
|
#### type DSAPublicKey
|
|
|
|
```go
|
|
type DSAPublicKey [128]byte
|
|
```
|
|
|
|
|
|
#### func (DSAPublicKey) Bytes
|
|
|
|
```go
|
|
func (k DSAPublicKey) Bytes() []byte
|
|
```
|
|
|
|
#### func (DSAPublicKey) Len
|
|
|
|
```go
|
|
func (k DSAPublicKey) Len() int
|
|
```
|
|
|
|
#### func (DSAPublicKey) NewVerifier
|
|
|
|
```go
|
|
func (k DSAPublicKey) NewVerifier() (v Verifier, err error)
|
|
```
|
|
create a new dsa verifier
|
|
|
|
#### type DSASigner
|
|
|
|
```go
|
|
type DSASigner struct {
|
|
}
|
|
```
|
|
|
|
|
|
#### func (*DSASigner) Sign
|
|
|
|
```go
|
|
func (ds *DSASigner) Sign(data []byte) (sig []byte, err error)
|
|
```
|
|
|
|
#### func (*DSASigner) SignHash
|
|
|
|
```go
|
|
func (ds *DSASigner) SignHash(h []byte) (sig []byte, err error)
|
|
```
|
|
|
|
#### type DSAVerifier
|
|
|
|
```go
|
|
type DSAVerifier struct {
|
|
}
|
|
```
|
|
|
|
|
|
#### func (*DSAVerifier) Verify
|
|
|
|
```go
|
|
func (v *DSAVerifier) Verify(data, sig []byte) (err error)
|
|
```
|
|
verify data with a dsa public key
|
|
|
|
#### func (*DSAVerifier) VerifyHash
|
|
|
|
```go
|
|
func (v *DSAVerifier) VerifyHash(h, sig []byte) (err error)
|
|
```
|
|
verify hash of data with a dsa public key
|
|
|
|
#### type Decrypter
|
|
|
|
```go
|
|
type Decrypter interface {
|
|
// decrypt a block of data
|
|
// return decrypted block or nil and error if error happens
|
|
Decrypt(data []byte) ([]byte, error)
|
|
}
|
|
```
|
|
|
|
decrypts data
|
|
|
|
#### type ECDSAVerifier
|
|
|
|
```go
|
|
type ECDSAVerifier struct {
|
|
}
|
|
```
|
|
|
|
|
|
#### func (*ECDSAVerifier) Verify
|
|
|
|
```go
|
|
func (v *ECDSAVerifier) Verify(data, sig []byte) (err error)
|
|
```
|
|
verify a block of data by hashing it and comparing the hash against the
|
|
signature
|
|
|
|
#### func (*ECDSAVerifier) VerifyHash
|
|
|
|
```go
|
|
func (v *ECDSAVerifier) VerifyHash(h, sig []byte) (err error)
|
|
```
|
|
verify a signature given the hash
|
|
|
|
#### type ECP256PrivateKey
|
|
|
|
```go
|
|
type ECP256PrivateKey [32]byte
|
|
```
|
|
|
|
|
|
#### type ECP256PublicKey
|
|
|
|
```go
|
|
type ECP256PublicKey [64]byte
|
|
```
|
|
|
|
|
|
#### func (ECP256PublicKey) Bytes
|
|
|
|
```go
|
|
func (k ECP256PublicKey) Bytes() []byte
|
|
```
|
|
|
|
#### func (ECP256PublicKey) Len
|
|
|
|
```go
|
|
func (k ECP256PublicKey) Len() int
|
|
```
|
|
|
|
#### func (ECP256PublicKey) NewVerifier
|
|
|
|
```go
|
|
func (k ECP256PublicKey) NewVerifier() (Verifier, error)
|
|
```
|
|
|
|
#### type ECP384PrivateKey
|
|
|
|
```go
|
|
type ECP384PrivateKey [48]byte
|
|
```
|
|
|
|
|
|
#### type ECP384PublicKey
|
|
|
|
```go
|
|
type ECP384PublicKey [96]byte
|
|
```
|
|
|
|
|
|
#### func (ECP384PublicKey) Bytes
|
|
|
|
```go
|
|
func (k ECP384PublicKey) Bytes() []byte
|
|
```
|
|
|
|
#### func (ECP384PublicKey) Len
|
|
|
|
```go
|
|
func (k ECP384PublicKey) Len() int
|
|
```
|
|
|
|
#### func (ECP384PublicKey) NewVerifier
|
|
|
|
```go
|
|
func (k ECP384PublicKey) NewVerifier() (Verifier, error)
|
|
```
|
|
|
|
#### type ECP521PrivateKey
|
|
|
|
```go
|
|
type ECP521PrivateKey [66]byte
|
|
```
|
|
|
|
|
|
#### type ECP521PublicKey
|
|
|
|
```go
|
|
type ECP521PublicKey [132]byte
|
|
```
|
|
|
|
|
|
#### func (ECP521PublicKey) Bytes
|
|
|
|
```go
|
|
func (k ECP521PublicKey) Bytes() []byte
|
|
```
|
|
|
|
#### func (ECP521PublicKey) Len
|
|
|
|
```go
|
|
func (k ECP521PublicKey) Len() int
|
|
```
|
|
|
|
#### func (ECP521PublicKey) NewVerifier
|
|
|
|
```go
|
|
func (k ECP521PublicKey) NewVerifier() (Verifier, error)
|
|
```
|
|
|
|
#### type Ed25519Decrypter
|
|
|
|
```go
|
|
type Ed25519Decrypter struct {
|
|
}
|
|
```
|
|
|
|
|
|
#### func (*Ed25519Decrypter) Decrypt
|
|
|
|
```go
|
|
func (d *Ed25519Decrypter) Decrypt(data []byte) ([]byte, error)
|
|
```
|
|
|
|
#### func (*Ed25519Decrypter) DecryptPadding
|
|
|
|
```go
|
|
func (d *Ed25519Decrypter) DecryptPadding(data []byte, zeroPadding bool) ([]byte, error)
|
|
```
|
|
|
|
#### type Ed25519Encryption
|
|
|
|
```go
|
|
type Ed25519Encryption struct {
|
|
}
|
|
```
|
|
|
|
|
|
#### func (*Ed25519Encryption) Encrypt
|
|
|
|
```go
|
|
func (ed25519 *Ed25519Encryption) Encrypt(data []byte) (enc []byte, err error)
|
|
```
|
|
|
|
#### func (*Ed25519Encryption) EncryptPadding
|
|
|
|
```go
|
|
func (ed25519 *Ed25519Encryption) EncryptPadding(data []byte, zeroPadding bool) (encrypted []byte, err error)
|
|
```
|
|
|
|
#### type Ed25519PrivateKey
|
|
|
|
```go
|
|
type Ed25519PrivateKey ed25519.PrivateKey
|
|
```
|
|
|
|
|
|
#### func (Ed25519PrivateKey) Bytes
|
|
|
|
```go
|
|
func (k Ed25519PrivateKey) Bytes() []byte
|
|
```
|
|
|
|
#### func (Ed25519PrivateKey) Generate
|
|
|
|
```go
|
|
func (k Ed25519PrivateKey) Generate() (SigningPrivateKey, error)
|
|
```
|
|
|
|
#### func (Ed25519PrivateKey) Len
|
|
|
|
```go
|
|
func (k Ed25519PrivateKey) Len() int
|
|
```
|
|
|
|
#### func (Ed25519PrivateKey) NewDecrypter
|
|
|
|
```go
|
|
func (k Ed25519PrivateKey) NewDecrypter() (Decrypter, error)
|
|
```
|
|
|
|
#### func (Ed25519PrivateKey) NewSigner
|
|
|
|
```go
|
|
func (k Ed25519PrivateKey) NewSigner() (Signer, error)
|
|
```
|
|
|
|
#### func (Ed25519PrivateKey) Public
|
|
|
|
```go
|
|
func (k Ed25519PrivateKey) Public() (SigningPublicKey, error)
|
|
```
|
|
|
|
#### func (Ed25519PrivateKey) Zero
|
|
|
|
```go
|
|
func (k Ed25519PrivateKey) Zero()
|
|
```
|
|
|
|
#### type Ed25519PublicKey
|
|
|
|
```go
|
|
type Ed25519PublicKey []byte
|
|
```
|
|
|
|
|
|
#### func CreateEd25519PublicKeyFromBytes
|
|
|
|
```go
|
|
func CreateEd25519PublicKeyFromBytes(data []byte) (Ed25519PublicKey, error)
|
|
```
|
|
|
|
#### func (Ed25519PublicKey) Bytes
|
|
|
|
```go
|
|
func (k Ed25519PublicKey) Bytes() []byte
|
|
```
|
|
|
|
#### func (Ed25519PublicKey) Len
|
|
|
|
```go
|
|
func (k Ed25519PublicKey) Len() int
|
|
```
|
|
|
|
#### func (Ed25519PublicKey) NewEncrypter
|
|
|
|
```go
|
|
func (elg Ed25519PublicKey) NewEncrypter() (enc Encrypter, err error)
|
|
```
|
|
|
|
#### func (Ed25519PublicKey) NewVerifier
|
|
|
|
```go
|
|
func (k Ed25519PublicKey) NewVerifier() (v Verifier, err error)
|
|
```
|
|
|
|
#### type Ed25519Signer
|
|
|
|
```go
|
|
type Ed25519Signer struct {
|
|
}
|
|
```
|
|
|
|
|
|
#### func (*Ed25519Signer) Sign
|
|
|
|
```go
|
|
func (s *Ed25519Signer) Sign(data []byte) (sig []byte, err error)
|
|
```
|
|
|
|
#### func (*Ed25519Signer) SignHash
|
|
|
|
```go
|
|
func (s *Ed25519Signer) SignHash(h []byte) (sig []byte, err error)
|
|
```
|
|
|
|
#### type Ed25519Verifier
|
|
|
|
```go
|
|
type Ed25519Verifier struct {
|
|
}
|
|
```
|
|
|
|
|
|
#### func (*Ed25519Verifier) Verify
|
|
|
|
```go
|
|
func (v *Ed25519Verifier) Verify(data, sig []byte) (err error)
|
|
```
|
|
|
|
#### func (*Ed25519Verifier) VerifyHash
|
|
|
|
```go
|
|
func (v *Ed25519Verifier) VerifyHash(h, sig []byte) (err error)
|
|
```
|
|
|
|
#### type ElgPrivateKey
|
|
|
|
```go
|
|
type ElgPrivateKey [256]byte
|
|
```
|
|
|
|
|
|
#### func (ElgPrivateKey) Len
|
|
|
|
```go
|
|
func (elg ElgPrivateKey) Len() int
|
|
```
|
|
|
|
#### func (ElgPrivateKey) NewDecrypter
|
|
|
|
```go
|
|
func (elg ElgPrivateKey) NewDecrypter() (dec Decrypter, err error)
|
|
```
|
|
|
|
#### type ElgPublicKey
|
|
|
|
```go
|
|
type ElgPublicKey [256]byte
|
|
```
|
|
|
|
|
|
#### func (ElgPublicKey) Bytes
|
|
|
|
```go
|
|
func (elg ElgPublicKey) Bytes() []byte
|
|
```
|
|
|
|
#### func (ElgPublicKey) Len
|
|
|
|
```go
|
|
func (elg ElgPublicKey) Len() int
|
|
```
|
|
|
|
#### func (ElgPublicKey) NewEncrypter
|
|
|
|
```go
|
|
func (elg ElgPublicKey) NewEncrypter() (enc Encrypter, err error)
|
|
```
|
|
|
|
#### type ElgamalEncryption
|
|
|
|
```go
|
|
type ElgamalEncryption struct {
|
|
}
|
|
```
|
|
|
|
|
|
#### func (*ElgamalEncryption) Encrypt
|
|
|
|
```go
|
|
func (elg *ElgamalEncryption) Encrypt(data []byte) (enc []byte, err error)
|
|
```
|
|
|
|
#### func (*ElgamalEncryption) EncryptPadding
|
|
|
|
```go
|
|
func (elg *ElgamalEncryption) EncryptPadding(data []byte, zeroPadding bool) (encrypted []byte, err error)
|
|
```
|
|
|
|
#### type Encrypter
|
|
|
|
```go
|
|
type Encrypter interface {
|
|
// encrypt a block of data
|
|
// return encrypted block or nil and error if an error happened
|
|
Encrypt(data []byte) (enc []byte, err error)
|
|
}
|
|
```
|
|
|
|
encrypts data
|
|
|
|
#### type HMACDigest
|
|
|
|
```go
|
|
type HMACDigest [16]byte
|
|
```
|
|
|
|
|
|
#### func I2PHMAC
|
|
|
|
```go
|
|
func I2PHMAC(data []byte, k HMACKey) (d HMACDigest)
|
|
```
|
|
do i2p hmac
|
|
|
|
#### type HMACKey
|
|
|
|
```go
|
|
type HMACKey [32]byte
|
|
```
|
|
|
|
|
|
#### type PrivateEncryptionKey
|
|
|
|
```go
|
|
type PrivateEncryptionKey interface {
|
|
// create a new decryption object for this private key to decrypt data encrypted to our public key
|
|
// returns decrypter or nil and error if the private key is in a bad format
|
|
NewDecrypter() (Decrypter, error)
|
|
}
|
|
```
|
|
|
|
|
|
#### type PrivateKey
|
|
|
|
```go
|
|
type PrivateKey interface {
|
|
// Public returns the public key corresponding to this private key
|
|
Public() (SigningPublicKey, error)
|
|
// Bytes returns the raw bytes of this private key
|
|
Bytes() []byte
|
|
// Zero clears all sensitive data from the private key
|
|
Zero()
|
|
}
|
|
```
|
|
|
|
PrivateKey is an interface for private keys
|
|
|
|
#### type PublicEncryptionKey
|
|
|
|
```go
|
|
type PublicEncryptionKey interface {
|
|
// create a new encrypter to encrypt data to this public key
|
|
NewEncrypter() (Encrypter, error)
|
|
|
|
// length of this public key in bytes
|
|
Len() int
|
|
}
|
|
```
|
|
|
|
|
|
#### type PublicKey
|
|
|
|
```go
|
|
type PublicKey interface {
|
|
Len() int
|
|
Bytes() []byte
|
|
}
|
|
```
|
|
|
|
|
|
#### type RSA2048PrivateKey
|
|
|
|
```go
|
|
type RSA2048PrivateKey [512]byte
|
|
```
|
|
|
|
|
|
#### type RSA2048PublicKey
|
|
|
|
```go
|
|
type RSA2048PublicKey [256]byte
|
|
```
|
|
|
|
|
|
#### func (RSA2048PublicKey) Bytes
|
|
|
|
```go
|
|
func (r RSA2048PublicKey) Bytes() []byte
|
|
```
|
|
Bytes implements SigningPublicKey.
|
|
|
|
#### func (RSA2048PublicKey) Len
|
|
|
|
```go
|
|
func (r RSA2048PublicKey) Len() int
|
|
```
|
|
Len implements SigningPublicKey.
|
|
|
|
#### func (RSA2048PublicKey) NewVerifier
|
|
|
|
```go
|
|
func (r RSA2048PublicKey) NewVerifier() (Verifier, error)
|
|
```
|
|
NewVerifier implements SigningPublicKey.
|
|
|
|
#### type RSA3072PrivateKey
|
|
|
|
```go
|
|
type RSA3072PrivateKey [786]byte
|
|
```
|
|
|
|
|
|
#### type RSA3072PublicKey
|
|
|
|
```go
|
|
type RSA3072PublicKey [384]byte
|
|
```
|
|
|
|
|
|
#### func (RSA3072PublicKey) Bytes
|
|
|
|
```go
|
|
func (r RSA3072PublicKey) Bytes() []byte
|
|
```
|
|
Bytes implements SigningPublicKey.
|
|
|
|
#### func (RSA3072PublicKey) Len
|
|
|
|
```go
|
|
func (r RSA3072PublicKey) Len() int
|
|
```
|
|
Len implements SigningPublicKey.
|
|
|
|
#### func (RSA3072PublicKey) NewVerifier
|
|
|
|
```go
|
|
func (r RSA3072PublicKey) NewVerifier() (Verifier, error)
|
|
```
|
|
NewVerifier implements SigningPublicKey.
|
|
|
|
#### type RSA4096PrivateKey
|
|
|
|
```go
|
|
type RSA4096PrivateKey [1024]byte
|
|
```
|
|
|
|
|
|
#### type RSA4096PublicKey
|
|
|
|
```go
|
|
type RSA4096PublicKey [512]byte
|
|
```
|
|
|
|
|
|
#### func (RSA4096PublicKey) Bytes
|
|
|
|
```go
|
|
func (r RSA4096PublicKey) Bytes() []byte
|
|
```
|
|
Bytes implements SigningPublicKey.
|
|
|
|
#### func (RSA4096PublicKey) Len
|
|
|
|
```go
|
|
func (r RSA4096PublicKey) Len() int
|
|
```
|
|
Len implements SigningPublicKey.
|
|
|
|
#### func (RSA4096PublicKey) NewVerifier
|
|
|
|
```go
|
|
func (r RSA4096PublicKey) NewVerifier() (Verifier, error)
|
|
```
|
|
NewVerifier implements SigningPublicKey.
|
|
|
|
#### type RecievingPublicKey
|
|
|
|
```go
|
|
type RecievingPublicKey interface {
|
|
Len() int
|
|
Bytes() []byte
|
|
NewEncrypter() (Encrypter, error)
|
|
}
|
|
```
|
|
|
|
|
|
#### type Signer
|
|
|
|
```go
|
|
type Signer interface {
|
|
// sign data with our private key by calling SignHash after hashing the data we are given
|
|
// return signature or nil signature and error if an error happened
|
|
Sign(data []byte) (sig []byte, err error)
|
|
|
|
// sign hash of data with our private key
|
|
// return signature or nil signature and error if an error happened
|
|
SignHash(h []byte) (sig []byte, err error)
|
|
}
|
|
```
|
|
|
|
type for signing data
|
|
|
|
#### type SigningPrivateKey
|
|
|
|
```go
|
|
type SigningPrivateKey interface {
|
|
// create a new signer to sign data
|
|
// return signer or nil and error if key format is invalid
|
|
NewSigner() (Signer, error)
|
|
// length of this private key
|
|
Len() int
|
|
// get public key or return nil and error if invalid key data in private key
|
|
Public() (SigningPublicKey, error)
|
|
// generate a new private key, put it into itself
|
|
// returns itself or nil and error if an error occurs
|
|
Generate() (SigningPrivateKey, error)
|
|
}
|
|
```
|
|
|
|
key for signing data
|
|
|
|
#### type SigningPublicKey
|
|
|
|
```go
|
|
type SigningPublicKey interface {
|
|
// create new Verifier to verify the validity of signatures
|
|
// return verifier or nil and error if key format is invalid
|
|
NewVerifier() (Verifier, error)
|
|
// get the size of this public key
|
|
Len() int
|
|
Bytes() []byte
|
|
}
|
|
```
|
|
|
|
key for verifying data
|
|
|
|
#### type Tunnel
|
|
|
|
```go
|
|
type Tunnel struct {
|
|
}
|
|
```
|
|
|
|
|
|
#### func NewTunnelCrypto
|
|
|
|
```go
|
|
func NewTunnelCrypto(layerKey, ivKey TunnelKey) (t *Tunnel, err error)
|
|
```
|
|
|
|
#### func (*Tunnel) Decrypt
|
|
|
|
```go
|
|
func (t *Tunnel) Decrypt(td *TunnelData)
|
|
```
|
|
|
|
#### func (*Tunnel) Encrypt
|
|
|
|
```go
|
|
func (t *Tunnel) Encrypt(td *TunnelData)
|
|
```
|
|
encrypt tunnel data in place
|
|
|
|
#### type TunnelData
|
|
|
|
```go
|
|
type TunnelData [1028]byte
|
|
```
|
|
|
|
|
|
#### type TunnelIV
|
|
|
|
```go
|
|
type TunnelIV []byte
|
|
```
|
|
|
|
The initialization vector for a tunnel message
|
|
|
|
#### type TunnelKey
|
|
|
|
```go
|
|
type TunnelKey [32]byte
|
|
```
|
|
|
|
A symetric key for encrypting tunnel messages
|
|
|
|
#### type Verifier
|
|
|
|
```go
|
|
type Verifier interface {
|
|
// verify hashed data with this signing key
|
|
// return nil on valid signature otherwise error
|
|
VerifyHash(h, sig []byte) error
|
|
// verify an unhashed piece of data by hashing it and calling VerifyHash
|
|
Verify(data, sig []byte) error
|
|
}
|
|
```
|
|
|
|
type for verifying signatures
|
|
|
|
|
|
|
|
crypto
|
|
|
|
github.com/go-i2p/go-i2p/lib/crypto
|