Go_I2p/lib/crypto/README.md

# crypto
--
    import "github.com/go-i2p/go-i2p/lib/crypto"

![crypto.svg](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