dongle

// Использование библиотеки из GitHub
go get -u github.com/dromara/dongle
import "github.com/dromara/dongle"

// Использование библиотеки из Gitee
go get -u gitee.com/dromara/dongle
import "gitee.com/dromara/dongle"

// Использование библиотеки из Gitcode
go get -u gitcode.com/dromara/dongle
import "gitcode.com/dromara/dongle"

### Пример использования

#### Шифрование & Расшифровка

##### Шифрование & Расшифровка в формате HEX

```go
// Шифрование строки в формате HEX, вывод строки
dongle.Encode.FromString("hello world").ByHex().ToString() // 68656c6c6f20776f726c64
// Расшифровка строки из HEX, вывод строки
dongle.Decode.FromString("68656c6c6f20776f726c64").ByHex().ToString() // hello world
```// Преобразование байтового среза в шестнадцатеричное представление, вывод байтового среза
dongle.Encode.FromBytes([]byte("hello world")).ByHex().ToBytes() // []byte("68656c6c6f20776f726c64")
// Декодирование байтового среза из шестнадцатеричного представления, вывод байтового среза
dongle.Decode.FromBytes([]byte("68656c6c6f20776f726c64")).ByHex().ToBytes() // []byte("hello world")

##### Базовая шестнадцатеричная (Base16) кодировка и декодировка

```go
// Кодирование строки в базовую шестнадцатеричную (base16)
dongle.Encode.FromString("hello world").ByBase16().ToString() // 68656c6c6f20776f726c64
// Декодирование строки из базовой шестнадцатеричной (base16)
dongle.Decode.FromString("68656c6c6f20776f726c64").ByBase16().ToString() // hello world

// Кодирование байтового среза в базовую шестнадцатеричную (base16)
dongle.Encode.FromBytes([]byte("hello world")).ByBase16().ToBytes() // []byte("68656c6c6f20776f726c64")
// Декодирование байтового среза из базовой шестнадцатеричной (base16)
dongle.Decode.FromBytes([]byte("68656c6c6f20776f726c64")).ByBase16().ToBytes() // []byte("hello world")

## Кодирование и декодирование данных

### Базовая триадная (Base32)

Кодирование байтового среза в базовую триадную (base32):
```go
dongle.Encode.FromBytes([]byte("hello world")).ByBase32().ToBytes() // []byte("NBSWY3DPEB3W64TMMQ======")
```
Декодирование байтового среза из базовой триадной (base32):
```go
dongle.Decode.FromBytes([]byte("NBSWY3DPEB3W64TMMQ======")).ByBase32().ToBytes() // []byte("hello world")
```

### Базовая пятидесятка (Base45)

Кодирование строки в базовую пятидесятку (base45):
```go
dongle.Encode.FromString("hello world").ByBase45().ToString() // "+8D VD82EK4F.KEA2"
```
Декодирование строки из базовой пятидесятки (base45):
```go
dongle.Decode.FromString("+8D VD82EK4F.KEA2").ByBase45().ToString() // "hello world"
```
Кодирование байтового среза в базовую пятидесятку (base45):
```go
dongle.Encode.FromBytes([]byte("hello world")).ByBase45().ToBytes() // []byte("+8D VD82EK4F.KEA2")
```
Декодирование байтового среза из базовой пятидесятки (base45):
```go
dongle.Decode.FromBytes([]byte("+8D VD82EK4F.KEA2")).ByBase45().ToBytes() // []byte("hello world")
```

### Базовая пятьдесят восемь (Base58)

Кодирование строки в базовую пятьдесят восемь (base58):
```go
dongle.Encode.FromString("hello world").ByBase58().ToString() // "StV1DL6CwTryKyV"
```
Декодирование строки из базовой пятьдесят восемь (base58):
```go
dongle.Decode.FromString("StV1DL6CwTryKyV").ByBase58().ToString() // "hello world"
```
Приведение байтового среза к base58 кодировке, вывод байтового среза:
```go
dongle.Encode.FromBytes([]byte("hello world")).ByBase58().ToBytes() // []byte("StV1DL6CwTryKyV")
```
Декодирование байтового среза из base58 кодировки, вывод байтового среза:
```go
dongle.Decode.FromBytes([]byte("StV1DL6CwTryKyV")).ByBase58().ToBytes() // []byte("hello world")
```

### Базовая шестидесятковичная (Base62)

Кодирование строки в базовую шестидесятковичную (base62):
```go
dongle.Encode.FromString("hello world").ByBase62().ToString() // "..."
```
Декодирование строки из базовой шестидесятковичной (base62):
```go
dongle.Decode.FromString("...").ByBase62().ToString() // "hello world"
```
Кодирование байтового среза в базовую шестидесятковичную (base62):
```go
dongle.Encode.FromBytes([]byte("hello world")).ByBase62().ToBytes() // []byte("...")
```
Декодирование байтового среза из базовой шестидесятковичной (base62):
```go
dongle.Decode.FromBytes([]byte("...")).ByBase62().ToBytes() // []byte("hello world")
```
```> Поддерживает пользовательскую таблицу символов, которая должна содержать 62 символа. По умолчанию используется таблица символов `0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz`.

```go
// Кодирует строку в base62 и выводит строку
dongle.Encode.FromString("hello world").ByBase62().ToString() // AAwf93rvy4aWQVw
// Декодирует строку из base62 и выводит строку
dongle.Decode.FromString("AAwf93rvy4aWQVw").ByBase62().ToString() // hello world

// Кодирует байтовый срез в base62 и выводит байтовый срез
dongle.Encode.FromBytes([]byte("hello world")).ByBase62().ToBytes() // []byte("AAwf93rvy4aWQVw")
// Декодирует байтовый срез из base62 и выводит байтовый срез
dongle.Decode.FromBytes([]byte("AAwf93rvy4aWQVw")).ByBase62().ToBytes() // []byte("hello world")

// Использует пользовательскую таблицу символов для кодирования байтового среза в base62 и выводит байтовый срез
dongle.Encode.FromBytes([]byte("hello world")).ByBase62("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789").ToBytes() // []byte("KK6pJD158Ekgaf6")
// Использует пользовательскую таблицу символов для декодирования байтового среза из base62 и выводит байтовый срез
dongle.Decode.FromBytes([]byte("KK6pJD158Ekgaf6")).ByBase62("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789").ToBytes() // []byte("hello world")
```

##### Базовая шестьдесятчетырёчная (base64) кодировка и декодировка

```go
// Кодирует строку в base64 и выводит строку
dongle.Encode.FromString("hello world").ByBase64().ToString() // aGVsbG8gd29ybGQ=
// Декодирует строку из base64 и выводит строку
dongle.Decode.FromString("aGVsbG8gd29ybGQ=").ByBase64().ToString() // hello world
```// Кодирует байтовый срез в base64 и выводит байтовый срез
dongle.Encode.FromBytes([]byte("hello world")).ByBase64().ToBytes() // []byte("aGVsbG8gd29ybGQ=")
// Декодирует байтовый срез из base64 и выводит байтовый срез
dongle.Decode.FromBytes([]byte("aGVsbG8gd29ybGQ=")).ByBase64().ToBytes() // []byte("hello world")##### Базовая шестьдесятичетырехичная URL (base64url) кодировка и декодировка

```go
// Кодирует URL-строку в base64url и выводит строку
dongle.Encode.FromString("www.gouguoyin.cn").ByBase64URL().ToString() // d3d3LmdvdWd1b3lpbi5jbg==
// Декодирует URL-строку из base64url и выводит строку
dongle.Decode.FromString("d3d3LmdvdWd1b3lpbi5jbg==").ByBase64URL().ToString() // www.gouguoyin.cn
```// Приведение байтового среза URL к base64, вывод байтового среза
dongle.Encode.FromBytes([]byte("www.gouguoyin.cn")).ByBase64URL().ToBytes() // []byte("d3d3LmdvdWd1b3lpbi5jbg==")
// Декодирование URL в base64, вывод байтового среза
dongle.Decode.FromBytes([]byte("d3d3LmdvdWd1b3lpbi5jbg==")).ByBase64URL().ToBytes() // []byte("www.gouguoyin.cn")

##### Кодирование и декодирование Base85

```go
// Кодирование строки в Base85, вывод строки
dongle.Encode.FromString("hello world").ByBase85().ToString() // BOu!rD]j7BEbo7
// Декодирование строки из Base85, вывод строки
dongle.Decode.FromString("BOu!rD]j7BEbo7").ByBase85().ToString() // hello world

// Кодирование байтового среза в Base85, вывод байтового среза
dongle.Encode.FromBytes([]byte("hello world")).ByBase85().ToBytes() // []byte("BOu!rD]j7BEbo7")
// Декодирование байтового среза из Base85, вывод байтового среза
dongle.Decode.FromBytes([]byte("BOu!rD]j7BEbo7")).ByBase85().ToBytes() // []byte("hello world")
```

##### Кодирование и декодирование Base91

```go
// Кодирование строки в Base91, вывод строки
dongle.Encode.FromString("hello world").ByBase91().ToString() // TPwJh>Io2Tv!lE
// Декодирование строки из Base91, вывод строки
dongle.Decode.FromString("TPwJh>Io2Tv!lE").ByBase91().ToString() // hello world
```// Кодирование байтового среза в Base91, вывод байтового среза
dongle.Encode.FromBytes([]byte("hello world")).ByBase91().ToBytes() // []byte("TPwJh>Io2Tv!lE")
// Декодирование байтового среза из Base91, вывод байтового среза
dongle.Decode.FromBytes([]byte("BOu!rD]j7BEbo7")).ByBase91().ToBytes() // []byte("hello world")##### Кодирование и декодирование Base100

```go
// Кодирование строки в Base100, вывод строки
dongle.Encode.FromString("hello world").ByBase100().ToString() // 👟👜👣👣👦🐗 pupperidge officer boy wife footsteps purse
// Декодирование строки из Base100, вывод строки
dongle.Decode.FromString("👟👜👣👣👦🐗 pupperidge officer boy wife footsteps purse").ByBase100().ToString() // hello world

// Кодирование байтового среза в Base100, вывод байтового среза
dongle.Encode.FromBytes([]byte("hello world")).ByBase100().ToBytes() // []byte("👟👜👣👣👦🐗 pupperidge officer boy wife footsteps purse")
// Декодирование байтового среза из Base100, вывод байтового среза
dongle.Decode.FromBytes([]byte("👟👜👣👣👦🐗 pupperidge officer boy wife footsteps purse")).ByBase100().ToBytes() // []byte("hello world")
```

##### Безопасное кодирование и декодирование URL

```go
// Преобразование символов URL в безопасное кодирование, вывод строки
dongle.Encode.FromString("www.gouguoyin.cn?sex=男&age=18").BySafeURL().ToString() // www.gouguoyin.cn%3Fsex%3D%E7%94%B7%26age%3D18
// Преобразование символов URL из безопасного кодирования, вывод строки
dongle.Decode.FromString("www.gouguoyin.cn%3Fsex%3D%E7%94%B7%26age%3D18").BySafeURL().ToString() // www.gouguoyin.cn?sex=男&age=18
```

```go
// Приведение байтового среза URL к escaped кодировке, вывод байтового среза
dongle.Encode.FromBytes([]byte("www.gouguoyin.cn?sex=男&age=18")).BySafeURL().ToBytes() // []byte("www.gouguoyin.cn%3Fsex%3D%E7%94%B7%26age%3D18")
// Декодирование escaped URL строки в байтовый срез
dongle.Decode.FromBytes([]byte("www.gouguoyin.cn%3Fsex%3D%E7%94%B7%26age%3D18")).BySafeURL().ToBytes() // []byte("www.gouguoyin.cn?sex=男&age=18")
```

##### Кодирование и декодирование Морзе

> По умолчанию разделитель — `/````go
// Кодирование строки методом Морзе, вывод строки
dongle.Encode.FromString("dongle").ByMorse().ToString() // -../---/-./--./.-../.
// Декодирование строки методом Морзе, вывод строки
dongle.Decode.FromString("-../---/-./--./.-../.").ByMorse().ToString() // dongle

// Кодирование байтового среза методом Морзе, вывод байтового среза
dongle.Encode.FromBytes([]byte("dongle")).ByMorse("|").ToBytes() // []byte("-..|---|-.|--.|.-..|.")
// Декодирование байтового среза методом Морзе, вывод байтового среза
dongle.Decode.FromBytes([]byte("-..|---|-.|--.|.-..|.")).ByMorse("|").ToBytes() // []byte("dongle")
```

#### Шифрование & Расшифровка

##### Шифрование MD2

```go
// Шифрование строки алгоритмом MD2, вывод шестнадцатеричной строки
dongle.Encrypt.FromString("hello world").ByMd2().ToHexString() // d9cce882ee690a5c1ce70beff3a78c77
// Шифрование строки алгоритмом MD2, вывод базовой 64-битной строки
dongle.Encrypt.FromString("hello world").ByMd2().ToBase64String() // 2czogu5pClwc5wvv86eMdw==

// Шифрование байтового среза алгоритмом MD2, вывод шестнадцатеричного байтового среза
dongle.Encrypt.FromBytes([]byte("hello world")).ByMd2().ToHexBytes() // []byte("d9cce882ee690a5c1ce70beff3a78c77") 
// Шифрование байтового среза алгоритмом MD2, вывод базового 64-битного байтового среза
dongle.Encrypt.FromBytes([]byte("hello world")).ByMd2().ToBase64Bytes() // []byte("2czogu5pClwc5wvv86eMdw==")
```

##### Шифрование MD4```go
// Шифрование строки алгоритмом MD4, вывод шестнадцатеричной строки
dongle.Encrypt.FromString("hello world").ByMd4().ToHexString() // aa010fbc1d14c795d86ef98c95479d17
// Шифрование строки алгоритмом MD4, вывод базовой 64-битной строки
dongle.Encrypt.FromString("hello world").ByMd4().ToBase64String() // qgEPvB0Ux5XYbvmMlUedFw==
```// Выполняет MD4-шифрование байтового среза и выводит зашифрованный срез в виде шестнадцатеричной строки
dongle.Encrypt.FromBytes([]byte("hello world")).ByMd4().ToHexBytes() // []byte("aa010fbc1d14c795d86ef98c95479d17")
// Выполняет MD4-шифрование байтового среза и выводит зашифрованный срез в виде строки Base64
dongle.Encrypt.FromBytes([]byte("hello world")).ByMd4().ToBase64Bytes() // []byte("qgEPvB0Ux5XYbvmMlUedFw==")

##### MD5 шифрование
``````go
// Шифрование строки с помощью MD5, вывод в виде шестнадцатеричной строки
dongle.Encrypt.FromString("hello world").ByMd5().ToHexString() // 5eb63bbbe01eeed093cb22bb8f5acdc3
// Шифрование строки с помощью MD5, вывод в виде строки Base64
dongle.Encrypt.FromString("hello world").ByMd5().ToBase64String() // XrY7u+Ae7tCTyyK7j1rNww==

// Шифрование байтового массива с помощью MD5, вывод в виде шестнадцатеричного байтового массива
dongle.Encrypt.FromBytes([]byte("hello world")).ByMd5().ToHexBytes() // []byte("5eb63bbbe01eeed093cb22bb8f5acdc3")
// Шифрование байтового массива с помощью MD5, вывод в виде байтового массива Base64
dongle.Encrypt.FromBytes([]byte("hello world")).ByMd5().ToBase64Bytes() // []byte("XrY7u+Ae7tCTyyK7j1rNww==")
```

##### SHA1 шифрование

```go
// Шифрование строки с помощью SHA1, вывод в виде шестнадцатеричной строки
dongle.Encrypt.FromString("hello world").BySha1().ToHexString() // 2aae6c35c94fcfb415dbe95f408b9ce91ee846ed
// Шифрование строки с помощью SHA1, вывод в виде строки Base64
dongle.Encrypt.FromString("hello world").BySha1().ToBase64String() // Kq5sNclPz7QV2+lfQIuc6R7oRu0=

// Шифрование байтового массива с помощью SHA1, вывод в виде шестнадцатеричного байтового массива
dongle.Encrypt.FromBytes([]byte("hello world")).BySha1().ToHexBytes() // []byte("2aae6c35c94fcfb415dbe95f408b9ce91ee846ed")
// Шифрование байтового массива с помощью SHA1, вывод в виде байтового массива Base64
dongle.Encrypt.FromBytes([]byte("hello world")).BySha1().ToBase64Bytes() // []byte("Kq5sNclPz7QV2+lfQIuc6R7oRu0=")
```

##### SHA3 шифрование

> Включает SHA3-224, SHA3-256, SHA3-384, SHA3-512
>```go
// Шифрование строки с помощью SHA3-224, вывод в виде шестнадцатеричной строки
dongle.Encrypt.FromString("hello world").Sha3(224).ToHexString() // dfb7f18c77e928bb56faeb2da27291bd790bc1045cde45f3210bb6c5
// Шифрование строки с помощью SHA3-224, вывод в виде строки Base64
dongle.Encrypt.FromString("hello world").Sha3(224).ToBase64String() // 37fxjHfpKLtW+ustonKRvXkLwQRc3kXzIQu2xQ==
// Шифрование байтового массива с помощью SHA3-224, вывод в виде шестнадцатеричного байтового массива
dongle.Encrypt.FromBytes([]byte("hello world")).Sha3(224).ToHexBytes() // []byte("dfb7f18c77e928bb56faeb2da27291bd790bc1045cde45f3210bb6c5")
// Шифрование байтового массива с помощью SHA3-224, вывод в виде байтового массива Base64
dongle.Encrypt.FromBytes([]byte("hello world")).Sha3(224).ToBase64Bytes() // []byte("37fxjHfpKLtW+ustonKRvXkLwQRc3kXzIQu2xQ==")

// Шифрование строки методом sha3-256 с выводом шестнадцатеричной записи
dongle.Encrypt.FromString("hello world").Sha3(256).ToHexString() // 644bcc7e564373040999aac89e7622f3ca71fba1d972fd94a31c3bfbf24e3938
// Шифрование строки методом sha3-256 с выводом закодированной в Base64 строки
dongle.Encrypt.FromString("hello world").Sha3(256).ToBase64String() // ZEvMflZDcwQJmarInnYi88px+6HZcv2Uoxw7+/JOOTg=
// Шифрование байтового массива методом sha3-256 с выводом шестнадцатеричной записи
dongle.Encrypt.FromBytes([]byte("hello world")).Sha3(256).ToHexBytes() // []byte("644bcc7e564373040999aac89e7622f3ca71fba1d972fd94a31c3bfbf24e3938")
// Шифрование байтового массива методом sha3-256 с выводом закодированной в Base64 строки
dongle.Encrypt.FromBytes([]byte("hello world")).Sha3(256).ToBase64Bytes() // []byte("ZEvMflZDcwQJmarInnYi88px+6HZcv2Uoxw7+/JOOTg=")
``````markdown
// Шифрование строки методом sha3-384 с выводом шестнадцатеричной записи
dongle.Encrypt.FromString("hello world").Sha3(384).ToHexString() // 83bff28dde1b1bf5810071c6643c08e5b05bdb836effd70b403ea8ea0a634dc4997eb1053aa3593f590f9c63630dd90b
// Шифрование строки методом sha3-384 с выводом закодированной в Base64 строки
dongle.Encrypt.FromString("hello world").Sha3(384).ToBase64String() // g7/yjd4bG/WBAHHGZDwI5bBb24Nu/9cLQD6o6gpjTcSZfrEFOqNZP1kPnGNjDdkL
// Шифрование байтового массива методом sha3-384 с выводом шестнадцатеричной записи
dongle.Encrypt.FromBytes([]byte("hello world")).Sha3(384).ToHexBytes() // []byte("83bff28dde1b1bf5810071c6643c08e5b05bdb836effd70b403ea8ea0a634dc4997eb1053aa3593f590f9c63630dd90b")
// Шифрование байтового массива методом sha3-384 с выводом закодированной в Base64 строки
dongle.Encrypt.FromBytes([]byte("hello world")).Sha3(384).ToBase64Bytes() // []byte("g7/yjd4bG/WBAHHGZDwI5bBb24Nu/9cLQD6o6gpjTcSZfrEFOqNZP1kPnGNjDdkL")
// Шифрование строки методом sha3-512, вывод в виде шестнадцатеричной закодированной строки
dongle.Encrypt.FromString("hello world").Sha3(512).ToHexString() // 840006653e9ac9e95117a15c915caab81662918e925de9e004f774ff82d7079a40d4d27b1b372657c61d46d470304c88c788b3a4527ad074d1dccbee5dbaa99a
// Шифрование строки методом sha3-512, вывод в виде базовой 64-битной закодированной строки
dongle.Encrypt.FromString("hello world").Sha3(512).ToBase64String() // hAAGZT6ayelRF6FckVyquBZikY6SXengBPd0/4LXB5pA1NJ7GzcmV8YdRtRwMEyIx4izpFJ60HTR3MvuXbqpmg==
// Шифрование байтового среза методом sha3-512, вывод в виде шестнадцатеричной закодированного байтового среза
dongle.Encrypt.FromBytes([]byte("hello world")).Sha3(512).ToHexBytes() // []byte("840006653e9ac9e95117a15c915caab81662918e925de9e004f774ff82d7079a40d4d27b1b372657c61d46d470304c88c788b3a4527ad074d1dccbee5dbaa99a")
```

Также исправлены знаки препинания и пробелы:

```markdown
// Шифрование строки методом sha3-384 с выводом шестнадцатеричной записи
dongle.Encrypt.FromString("hello world").Sha3(384).ToHexString() // 83bff28dde1b1bf5810071c6643c08e5b05bdb836effd70b403ea8ea0a634dc4997eb1053aa3593f590f9c63630dd90b
// Шифрование строки методом sha3-384 с выводом закодированной в Base64 строки
dongle.Encrypt.FromString("hello world").Sha3(384).ToBase64String() // g7/yjd4bG/WBAHHGZDwI5bBb24Nu/9cLQD6o6gpjTcSZfrEFOqNZP1kPnGNjDdkL
// Шифрование байтового массива методом sha3-384 с выводом шестнадцатеричной записи
dongle.Encrypt.FromBytes([]byte("hello world")).Sha3(384).ToHexBytes() // []byte("83bff28dde1b1bf5810071c6643c08e5b05bdb836effd70b403ea8ea0a634dc4997eb1053aa3593f590f9c63630dd90b")
// Шифрование байтового массива методом sha3-384 с выводом закодированной в Base64 строки
dongle.Encrypt.FromBytes([]byte("hello world")).Sha3(384).ToBase64Bytes() // []byte("g7/yjd4bG/WBAHHGZDwI5bBb24Nu/9cLQD6o6gpjTcSZfrEFOqNZP1kPnGNjDdkL")
// Шифрование строки методом sha3-512, вывод в виде шестнадцатеричной закодированной строки
dongle.Encrypt.FromString("hello world").Sha3(512).ToHexString() // 840006653e9ac9e95117a15c915caab81662918e925de9e004f774ff82d7079a40d4d27b1b372657c61d46d470304c88c788b3a4527ad074d1dccbee5dbaa99a
// Шифрование строки методом sha3-512, вывод в виде базовой 64-битной закодированной строки
dongle.Encrypt.FromString("hello world").Sha3(512).ToBase64String() // hAAGZT6ayelRF6FckVyquBZikY6SXengBPd0/4LXB5pA1NJ7GzcmV8YdRtRwMEyIx4izpFJ60HTR3MvuXbqpmg==
// Шифрование байтового среза методом sha3-512, вывод в виде шестнадцатеричной закодированного байтового среза
dongle.Encrypt.FromBytes([]byte("hello world")).Sha3(512).ToHexBytes() // []byte("840006653e9ac9e95117a15c915caab81662918e925de9e004f774ff82d7079a40d4d27b1b372657c61d46d470304c88c788b3a4527ad074d1dccbee5dbaa99a")
```// Шифрование байтового среза методом sha3-512, вывод в виде базовой 64-битной закодированного байтового среза
dongle.Encrypt.FromBytes([]byte("hello world")).Sha3(512).ToBase64Bytes() // []byte("hAAGZT6ayelRF6FckVyquBZikY6SXengBPd0/4LXB5pA1NJ7GzcmV8YdRtRwMEyIx4izpFJ60HTR3MvuXbqpmg==")```##### Шифрование SHA224

```go
// Зашифровать строку с помощью SHA224, вывести шестнадцатеричное представление строки
dongle.Encrypt.FromString("hello world").BySha224().ToHexString() // 2f05477fc24bb4faefd86517156dafdecec45b8ad3cf2522a563582b
// Зашифровать строку с помощью SHA224, вывести закодированное Base64 представление строки
dongle.Encrypt.FromString("hello world").BySha224().ToBase64String() // LwVHf8JLtPrv2GUXFW2v3s7EW4rTzyUipWNYKw==

// Зашифровать байтовую последовательность с помощью SHA224, вывести шестнадцатеричное представление байтовой последовательности
dongle.Encrypt.FromBytes([]byte("hello world")).BySha224().ToHexBytes() // []byte("2f05477fc24bb4faefd86517156dafdecec45b8ad3cf2522a563582b")
// Зашифровать байтовую последовательность с помощью SHA224, вывести закодированное Base64 представление байтовой последовательности
dongle.Encrypt.FromBytes([]byte("hello world")).BySha224().ToBase64Bytes() // []byte("LwVHf8JLtPrv2GUXFW2v3s7EW4rTzyUipWNYKw==")
```

##### Шифрование SHA256

```go
// Зашифровать строку с помощью SHA256, вывести шестнадцатеричное представление строки
dongle.Encrypt.FromString("hello world").BySha256().ToHexString() // b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9
// Зашифровать строку с помощью SHA256, вывести закодированное Base64 представление строки
dongle.Encrypt.FromString("hello world").BySha256().ToBase64String() // uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek=
```// Зашифровать байтовую последовательность с помощью SHA256, вывести шестнадцатеричное представление байтовой последовательности
dongle.Encrypt.FromBytes([]byte("hello world")).BySha256().ToHexBytes() // []byte("b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9")
// Зашифровать байтовую последовательность с помощью SHA256, вывести закодированное Base64 представление байтовой последовательности
dongle.Encrypt.FromBytes([]byte("hello world")).BySha256().ToBase64Bytes() // []byte("uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek=")
```##### Шифрование SHA384

```go
// Зашифровать строку с помощью SHA384, вывести шестнадцатеричное представление строки
dongle.Encrypt.FromString("hello world").BySha384().ToHexString() // fdbd8e75a67f29f701a4e040385e2e23986303ea10239211af907fcbb83578b3e417cb71ce646efd0819dd8c088de1bd
// Зашифровать строку с помощью SHA384, вывести закодированное Base64 представление строки
dongle.Encrypt.FromString("hello world").BySha384().ToBase64String() // /b2OdaZ/KfcBpOBAOF4uI5hjA+oQI5IRr5B/y7g1eLPkF8txzmRu/QgZ3YwIjeG9
```

Выполняет шифрование байтового среза методом sha384, выводит зашифрованные данные в виде шестнадцатеричной строки
dongle.Encrypt.FromBytes([]byte("hello world")).BySha384().ToHexBytes() // []byte("fdbd8e75a67f29f701a4e040385e2e23986303ea10239211af907fcbb83578b3e417cb71ce646efd0819dd8c088de1bd")

Выполняет шифрование байтового среза методом sha384, выводит зашифрованные данные в виде строки base64
dongle.Encrypt.FromBytes([]byte("hello world")).BySha384().ToBase64Bytes() // []byte("/b2OdaZ/KfcBpOBAOF4uI5hjA+oQI5IRr5B/y7g1eLPkF8txzmRu/QgZ3YwIjeG9")

##### Шифрование SHA512

> Включает sha512, sha512-224, sha512-256```go
// Encrypts a string using SHA512 and outputs the encrypted string in hexadecimal representation
dongle.Encrypt.FromString("hello world").BySha512().ToHexBytes() // 309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f
// Encrypts a string using SHA512 and outputs the encrypted string in base64 encoding
dongle.Encrypt.FromString("hello world").BySha512().ToBase64String() // MJ7MSJwS1utMxA9QyQLytNDtd+5RGnx6m808qG1M2G+YndNbxf9JlnDaNCVbRbDP2DDoH2Bdz33FVC6TrpzXbw==
// Encrypts a byte array using SHA512 and outputs the encrypted array in hexadecimal representation
dongle.Encrypt.FromBytes([]byte("hello world")).BySha512().ToHexBytes() // []byte("309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f")
// Encrypts a byte array using SHA512 and outputs the encrypted array in base64 encoding
dongle.Encrypt.FromBytes([]byte("hello world")).BySha512().ToBase64Bytes() // []byte("MJ7MSJwS1utMxA9QyQLytNDtd+5RGnx6m808qG1M2G+YndNbxf9JlnDaNCVbRbDP2DDoH2Bdz33FVC6TrpzXbw==")
``````markdown
// Шифрование строки с помощью алгоритма SHA512-224, вывод зашифрованной строки в шестнадцатеричном формате
dongle.Encrypt.FromString("hello world").BySha512(224).ToHexBytes() // 22e0d52336f64a998085078b05a6e37b26f8120f43bf4db4c43a64ee
// Шифрование строки с помощью алгоритма SHA512-224, вывод зашифрованной строки в формате Base64
dongle.Encrypt.FromString("hello world").BySha512(224).ToBase64String() // IuDVIzb2SpmAhQeLBabjeyb4Eg9Dv020xDpk7g==
// Шифрование байтового массива с помощью алгоритма SHA512-224, вывод зашифрованного байтового массива в шестнадцатеричном формате
dongle.Encrypt.FromBytes([]byte("hello world")).BySha512(224).ToHexBytes() // []byte("22e0d52336f64a998085078b05a6e37b26f8120f43bf4db4c43a64ee")
// Шифрование байтового массива с помощью алгоритма SHA512-224, вывод зашифрованного байтового массива в формате Base64
dongle.Encrypt.FromBytes([]byte("hello world")).BySha512(224).ToBase64Bytes() // []byte("IuDVIzb2SpmAhQeLBabjeyb4Eg9Dv020xDpk7g==")

// Шифрование строки с помощью алгоритма SHA512-256, вывод зашифрованной строки в шестнадцатеричном формате
dongle.Encrypt.FromString("hello world").BySha512(256).ToHexBytes() // 0ac561fac838104e3f2e4ad107b4bee3e938bf15f2b15f009ccccd61a913f017
// Шифрование строки с помощью алгоритма SHA512-256, вывод зашифрованной строки в формате Base64
dongle.Encrypt.FromString("hello world").BySha512(256).ToBase64String() // CsVh+sg4EE4/LkrRB7S+4+k4vxXysV8AnMzNYakT8Bc=
// Шифрование байтового массива с помощью алгоритма SHA512-256, вывод зашифрованного байтового массива в шестнадцатеричном формате
dongle.Encrypt.FromBytes([]byte("hello world")).BySha512(256).ToHexBytes() // []byte("0ac561fac838104e3f2e4ad107b4bee3e938bf15f2b15f009ccccd61a913f017")
```// Шифрование байтового массива с помощью алгоритма sha512-256, вывод зашифрованного байтового массива в формате Base64
dongle.Encrypt.FromBytes([]byte("hello world")).BySha512(256).ToBase64Bytes() // []byte("CsVh+sg4EE4/LkrRB7S+4+k4vxXysV8AnMzNYakT8Bc=")
```##### Шифрование SHAKE128``````go
// Encrypt the string using SHAKE128-256 and output the encrypted hexadecimal code of the string
dongle.Encrypt.FromString("hello world").ByShake128(256).ToHexString() // 3a9159f071e4dd1c8c4f968607c30942e120d8156b8b1e72e0d376e8871cb8b8
// Encrypt the string using SHAKE128-256 and output the encrypted Base64 code of the string
dongle.Encrypt.FromString("hello world").ByShake128(256).ToBase64String() // OpFZ8HHk3RyMT5aGB8MJQuEg2BVrix5y4NN26IccuLg=
// Encrypt the byte array using SHAKE128-256 and output the encrypted hexadecimal code of the byte array
dongle.Encrypt.FromBytes([]byte("hello world")).ByShake128(256).ToHexBytes() // []byte("3a9159f071e4dd1c8c4f968607c30942e120d8156b8b1e72e0d376e8871cb8b8")
// Encrypt the byte array using SHAKE128-256 and output the encrypted Base64 code of the byte array
dongle.Encrypt.FromBytes([]byte("hello world")).ByShake128(256).ToBase64Bytes() // []byte("OpFZ8HHk3RyMT5aGB8MJQuEg2BVrix5y4NN26IccuLg=")
```// Шифрование строки с использованием SHAKE128-512, вывод зашифрованного шестнадцатеричного кода строки
dongle.Encrypt.FromString("hello world").ByShake128(512).ToHexString() // 3a9159f071e4dd1c8c4f968607c30942e120d8156b8b1e72e0d376e8871cb8b899072665674f26cc494a4bcf027c58267e8ee2da60e942759de86d2670bba1aa
// Шифрование строки с использованием SHAKE128-512, вывод зашифрованного Base64 кода строки
dongle.Encrypt.FromString("hello world").ByShake128(512).ToBase64String() // OpFZ8HHk3RyMT5aGB8MJQuEg2BVrix5y4NN26IccuLiZByZlZ08mzElKS88CfFgmfo7i2mDpQnWd6G0mcLuhqg==
// Шифрование байтового массива с использованием SHAKE128-512, вывод зашифрованного шестнадцатеричного кода байтового массива
dongle.Encrypt.FromBytes([]byte("hello world")).ByShake128(512).ToHexBytes() // []byte("3a9159f071e4dd1c8c4f968607c30942e120d8156b8b1e72e0d376e8871cb8b899072665674f26cc494a4bcf027c58267e8ee2da60e942759de86d2670bba1aa")
// Шифрование байтового массива с использованием SHAKE128-512, вывод зашифрованного Base64 кода байтового массива
dongle.Encrypt.FromBytes([]byte("hello world")).ByShake128(512).ToBase64Bytes() // []byte("OpFZ8HHk3RyMT5aGB8MJQuEg2BVrix5y4NN26IccuLiZByZlZ08mzElKS88CfFgmfo7i2mDpQnWd6G0mcLuhqg==")
```##### Шифрование SHAKE256```go
 // Шифрование строки с использованием shake256-384, вывод в виде шестнадцатеричной закодированной строки
 dongle.Encrypt.FromString("hello world").ByShake256(384).ToHexString() // 369771bb2cb9d2b04c1d54cca487e372d9f187f73f7ba3f65b95c8ee7798c527f4f3c2d55c2d46a29f2e945d469c3df2
 // Шифрование строки с использованием shake256-384, вывод в виде базовой 64-битной закодированной строки
 dongle.Encrypt.FromString("hello world").ByShake256(384).ToBase64String() // Npdxuyy50rBMHVTMpIfjctnxh/c/e6P2W5XI7neYxSf088LVXC1Gop8ulF1GnD3y
 // Шифрование байтового слайса с использованием shake256-384, вывод в виде шестнадцатеричной закодированного байтового слайса
 dongle.Encrypt.FromBytes([]byte("hello world")).ByShake256(384).ToHexBytes() // []byte("369771bb2cb9d2b04c1d54cca487e372d9f187f73f7ba3f65b95c8ee7798c527f4f3c2d55c2d46a29f2e945d469c3df2")
 // Шифрование байтового слайса с использованием shake256-384, вывод в виде базовой 64-битной закодированного байтового слайса
 dongle.Encrypt.FromBytes([]byte("hello world")).ByShake256(384).ToBase64Bytes() // []byte("Npdxuyy50rBMHVTMpIfjctnxh/c/e6P2W5XI7neYxSf088LVXC1Gop8ulF1GnD3y")
 ```// Применение шифрования shake256-512 к строке, вывод в виде шестнадцатеричной строки
 dongle.Encrypt.FromString("hello world").ByShake256(512).ToHexString() // 369771bb2cb9d2b04c1d54cca487e372d9f187f73f7ba3f65b95c8ee7798c527f4f3c2d55c2d46a29f2e945d469c3df27853a8735271f5cc2d9e889544357116
 // Применение шифрования shake256-512 к строке, вывод в виде строки закодированной Base64
 dongle.Encrypt.FromString("hello world").ByShake256(512).ToBase64String() // Npdxuyy50rBMHVTMpIfjctnxh/c/e6P2W5XI7neYxSf088LVXC1Gop8ulF1GnD3yeFOoc1Jx9cwtnoiVRDVxFg==
 // Применение шифрования shake256-512 к байтовому срезу, вывод в виде шестнадцатеричной строки
 dongle.Encrypt.FromBytes([]byte("hello world")).ByShake256(512).ToHexString()ToHexBytes() // []byte("369771bb2cb9d2b04c1d54cca487e372d9f187f73f7ba3f65b95c8ee7798c527f4f3c2d55c2d46a29f2e945d469c3df27853a8735271f5cc2d9e889544357116")
// Применение шифрования shake256-512 к байтовому срезу, вывод в виде строки закодированной Base64
dongle.Encrypt.FromBytes([]byte("hello world")).ByShake256(512).ToBase64Bytes() // []byte("Npdxuyy50rBMHVTMpIfjctnxh/c/e6P2W5XI7neYxSf088LVXC1Gop8ulF1GnD3yeFOoc1Jx9cwtnoiVRDVxFg==")```
##### Шифрование Ripemd160

```go
// Применение шифрования ripemd160 к строке, вывод в виде шестнадцатеричной строки
dongle.Encrypt.FromString("hello world").ByRipemd160().ToHexString() // 98c615784ccb5fe5936fbc0cbe9dfdb408d92f0f
// Применение шифрования ripemd160 к строке, вывод в виде строки закодированной Base64
dongle.Encrypt.FromString("hello world").ByRipemd160().ToBase64String() // mMYVeEzLX+WTb7wMvp39tAjZLw8=

// Применение шифрования ripemd160 к байтовому срезу, вывод в виде шестнадцатеричной строки
dongle.Encrypt.FromBytes([]byte("hello world")).ByRipemd160().ToHexBytes() // []byte("98c615784ccb5fe5936fbc0cbe9dfdb408d92f0f")
// Применение шифрования ripemd160 к байтовому срезу, вывод в виде строки закодированной Base64
dongle.Encrypt.FromBytes([]byte("hello world")).ByRipemd160().ToBase64Bytes() // []byte("mMYVeEzLX+WTb7wMvp39tAjZLw8=")
```

##### Шифрование Blake2b
> Включает blake2b-256, blake2b-384, blake2b-512

```go
// Шифрование строки методом blake2b-256, вывод в виде шестнадцатеричного кода
dongle.Encrypt.FromString("hello world").ByBlake2b(256).ToHexBytes() // 256c83b297114d201b30179f3f0ef0cace9783622da5974326b436178aeef610
// Шифрование строки методом blake2b-256, вывод в виде закодированной строки base64
dongle.Encrypt.FromString("hello world").ByBlake2b(256).ToBase64String() // JWyDspcRTSAbMBefPw7wys6Xg2ItpZdDJrQ2F4ru9hA=
// Шифрование байтового среза методом blake2b-256, вывод в виде шестнадцатеричного кода
dongle.Encrypt.FromBytes([]byte("hello world")).ByBlake2b(256).ToHexBytes() // []byte("256c83b297114d201b30179f3f0ef0cace9783622da5974326b436178aeef610")
// Шифрование байтового среза методом blake2b-256, вывод в виде закодированного байтового среза base64
dongle.Encrypt.FromBytes([]byte("hello world")).ByBlake2b(256).ToBase64Bytes() // []byte("JWyDspcRTSAbMBefPw7wys6Xg2ItpZdDJrQ2F4ru9hA=")
```### Шифрование строки blake2b-384 с выводом шестнадцатеричной записи
```python
dongle.Encrypt.FromString("hello world").ByBlake2b(384).ToHexBytes() # 8c653f8c9c9aa2177fb6f8cf5bb914828faa032d7b486c8150663d3f6524b086784f8e62693171ac51fc80b7d2cbb12b
```
### Шифрование строки blake2b-384 с выводом закодированной в Base64 строки
```python
dongle.Encrypt.FromString("hello world").ByBlake2b(384).ToBase64String() # jGU/jJyaohd/tvjPW7kUgo+qAy17SGyBUGY9P2UksIZ4T45iaTFxrFH8gLfSy7Er
```
### Шифрование байтового массива blake2b-384 с выводом шестнадцатеричной записи
```python
dongle.Encrypt.FromBytes([]byte("hello world")).ByBlake2b(384).ToHexBytes() # []byte("8c653f8c9c9aa2177fb6f8cf5bb914828faa032d7b486c8150663d3f6524b086784f8e62693171ac51fc80b7d2cbb12b")
```
### Шифрование байтового массива blake2b-384 с выводом закодированного в Base64 байтового массива
```python
dongle.Encrypt.FromBytes([]byte("hello world")).ByBlake2b(384).ToBase64Bytes() # []byte("jGU/jJyaohd/tvjPW7kUgo+qAy17SGyBUGY9P2UksIZ4T45iaTFxrFH8gLfSy7Er")
```

## Шифрование с использованием Blake2b### Шифрование строки blake2b-512 с выводом шестнадцатеричной записи
```python
dongle.Encrypt.FromString("hello world").ByBlake2b(512).ToHexBytes() # 021ced8799296ceca557832ab941a50b4a11f83478cf141f51f933f653ab9fbcc05a037cddbed06e309bf334942c4e58cdf1a46e237911ccd7fcf9787cbc7fd0
```
### Шифрование строки blake2b-512 с выводом закодированной в Base64 строки
```python
dongle.Encrypt.FromString("hello world").ByBlake2b(512).ToBase64String() # Ahzth5kpbOylV4MquUGlC0oR+DR4zxQfUfkz9lOrn7zAWgN83b7QbjCb8zSULE5YzfGkbiN5EczX/Pl4fLx/0A==
```
### Шифрование байтового массива blake2b-512 с выводом шестнадцатеричной записи
```python
dongle.Encrypt.FromBytes([]byte("hello world")).ByBlake2b(512).ToHexBytes() # []byte("021ced8799296ceca557832ab941a50b4a11f83478cf141f51f933f653ab9fbcc05a037cddbed06e309bf334942c4e58cdf1a46e237911ccd7fcf9787cbc7fd0")
```
### Шифрование байтового массива blake2b-512 с выводом закодированного в Base64 байтового массива
```python
dongle.Encrypt.FromBytes([]byte("hello world")).ByBlake2b(512).ToBase64Bytes() # []byte("Ahzth5kpbOylV4MquUGlC0oR+DR4zxQfUfkz9lOrn7zAWgN83b7QbjCb8zSULE5YzfGkbiN5EczX/Pl4fLx/0A==")
```##### Шифрование с использованием Blake2s
> В настоящее время поддерживаются только blake2s-256```go
// Шифрование строки методом blake2s-256, вывод в виде шестнадцатеричной закодированной строки
dongle.Encrypt.FromString("hello world").ByBlake2s(256).ToHexString() // 9aec6806794561107e594b1f6a8a6b0c92a0cba9acf5e5e93cca06f781813b0b
// Шифрование строки методом blake2s-256, вывод в виде базовой 64-битной закодированной строки
dongle.Encrypt.FromString("hello world").ByBlake2s(256).ToBase64String() // muxoBnlFYRB+WUsfaoprDJKgy6ms9eXpPMoG94GBOws=
```### Blake2s-256 шифрование

```go
# Шифрование байтового среза методом blake2s-256, вывод зашифрованного байтового среза в hex-коде
dongle.Encrypt.FromBytes([]byte("hello world")).ByBlake2s(256).ToHexBytes() # []byte("9aec6806794561107e594b1f6a8a6b0c92a0cba9acf5e5e93cca06f781813b0b")
# Шифрование байтового среза методом blake2s-256, вывод зашифрованного байтового среза в base64-коде
dongle.Encrypt.FromBytes([]byte("hello world")).ByBlake2s(256).ToBase64Bytes() # []byte("muxoBnlFYRB+WUsfaoprDJKgy6ms9eXpPMoG94GBOws=")
```

#### HMAC-MD2 шифрование

```go
# Шифрование строки методом hmac-md2, вывод зашифрованной строки в hex-коде
dongle.Encrypt.FromString("hello world").ByHmacMd2([]byte("dongle")).ToHexString() # 88ed6ef9ab699d03a702f2a6fb1c0673
# Шифрование строки методом hmac-md2, вывод зашифрованной строки в base64-коде
dongle.Encrypt.FromString("hello world").ByHmacMd2([]byte("dongle")).ToBase64String() # iO1u+atpnQOnAvKm+xwGcw==
```# Шифрование байтового среза методом hmac-md2, вывод зашифрованного байтового среза в hex-коде
dongle.Encrypt.FromBytes([]byte("hello world")).ByHmacMd2([]byte("dongle")).ToHexBytes() # []byte("88ed6ef9ab699d03a702f2a6fb1c0673")
# Шифрование байтового среза методом hmac-md2, вывод зашифрованного байтового среза в base64-коде
dongle.Encrypt.FromBytes([]byte("hello world")).ByHmacMd2([]byte("dongle")).ToBase64Bytes() # []byte("iO1u+atpnQOnAvKm+xwGcw==")
```#### HMAC-MD4 шифрование

```go
# Шифрование строки методом hmac-md4, вывод зашифрованной строки в hex-коде
dongle.Encrypt.FromString("hello world").ByHmacMd4([]byte("dongle")).ToHexString() # 7a9df5247cbf76a8bc17c9c4f5a75b6b
# Шифрование строки методом hmac-md4, вывод зашифрованной строки в base64-коде
dongle.Encrypt.FromString("hello world").ByHmacMd4([]byte("dongle")).ToBase64String() # ep31JHy/dqi8F8nE9adbaw==

# Шифрование байтового среза методом hmac-md4, вывод зашифрованного байтового среза в hex-коде
dongle.Encrypt.FromBytes([]byte("hello world")).ByHmacMd4([]byte("dongle")).ToHexBytes() # []byte("7a9df5247cbf76a8bc17c9c4f5a75b6b")
# Шифрование байтового среза методом hmac-md4, вывод зашифрованного байтового среза в base64-коде
dongle.Encrypt.FromBytes([]byte("hello world")).ByHmacMd4([]byte("dongle")).ToBase64Bytes() # []byte("ep31JHy/dqi8F8nE9adbaw==")
```

##### HMAC-MD5 шифрование

```go
// Выполняет HMAC-MD5 шифрование строки, выводит зашифрованное значение в виде шестнадцатеричной строки
dongle.Encrypt.FromString("hello world").ByHmacMd5([]byte("dongle")).ToHexString() // 4790626a275f776956386e5a3ea7b726
// Выполняет HMAC-MD5 шифрование строки, выводит зашифрованное значение в виде Base64 строки
dongle.Encrypt.FromString("hello world").ByHmacMd5([]byte("dongle")).ToBase64String() // R5Biaidfd2lWOG5aPqe3Jg==
```
// HMAC-MD5 шифрование байтового среза, вывод через шестнадцатеричное кодирование байтового среза
dongle.Encrypt.FromBytes([]byte("hello world")).ByHmacMd5([]byte("dongle")).ToHexBytes() // []byte("4790626a275f776956386e5a3ea7b726")
// HMAC-MD5 шифрование байтового среза, вывод через Base64 кодирование байтового среза
dongle.Encrypt.FromBytes([]byte("hello world")).ByHmacMd5([]byte("dongle")).ToBase64Bytes() // []byte("R5Biaidfd2lWOG5aPqe3Jg==")##### HMAC-SHA1 шифрование

```go
// HMAC-SHA1 шифрование строки, вывод через шестнадцатеричное кодирование строки
dongle.Encrypt.FromString("hello world").ByHmacSha1([]byte("dongle")).ToHexString() // 91c103ef93ba7420902b0d1bf0903251c94b4a62
// HMAC-SHA1 шифрование строки, вывод через Base64 кодирование строки
dongle.Encrypt.FromString("hello world").ByHmacSha1([]byte("dongle")).ToBase64String() // kcED75O6dCCQKw0b8JAyUclLSmI=
// HMAC-SHA1 шифрование байтового среза, вывод через шестнадцатеричное кодирование байтового среза
dongle.Encrypt.FromBytes([]byte("hello world")).ByHmacSha1([]byte("dongle")).ToHexBytes() // []byte("91c103ef93ba7420902b0d1bf0903251c94b4a62")
// HMAC-SHA1 шифрование байтового среза, вывод через Base64 кодирование байтового среза
dongle.Encrypt.FromBytes([]byte("hello world")).ByHmacSha1([]byte("dongle")).ToBase64Bytes() // []byte("kcED75O6dCCQKw0b8JAyUclLSmI=")
```

##### HMAC-SHA3 шифрование

> Включает HMAC-SHA3-224, HMAC-SHA3-256, HMAC-SHA3-384, HMAC-SHA3-512```go
 // HMAC-SHA3-224 шифрование строки, вывод через шестнадцатеричное кодирование строки
 dongle. Encrypt. FromString("hello world"). ByHmacSha3([]byte("dongle"), 224). ToHexString() // fb8f061d9d1dddd2f5d3b9064a5e98e3e4b6df27ea93ce67627583ce
 // HMAC-SHA3-224 шифрование строки, вывод через Base64 кодирование строки
 dongle. Encrypt. FromString("hello world"). ByHmacSha3([]byte("dongle"), 224). ToBase64String() // +48GHZ0d3dL107kGSl6Y4+S23yfqk85nYnWDzg==
 // HMAC-SHA3-224 шифрование байтового среза, вывод через шестнадцатеричное кодирование байтового среза
 dongle. Encrypt. FromBytes([]byte("hello world")). ByHmacSha3([]byte("dongle"), 224). ToHexBytes() // []byte("fb8f061d9d1dddd2f5d3b9064a5e98e3e4b6df27ea93ce67627583ce")
 // HMAC-SHA3-224 шифрование байтового среза, вывод через Base64 кодирование байтового среза
 dongle. Encrypt. FromBytes([]byte("hello world")). ByHmacSha3([]byte("dongle"), 224). ToBase64Bytes() // []byte("+48GHZ0d3dL107kGSl6Y4+S23yfqk85nYnWDzg==")
 ```// Выполняет HMAC-SHA3-256 шифрование строки, выводит зашифрованную строку в виде шестнадцатеричной строки
 dongle. Encrypt. FromString("hello world"). ByHmacSha3([]byte("dongle"), 256). ToHexString() // 8193367fde28cf5c460adb449a04b3dd9c184f488bdccbabf0526c54f90c4460
 // Выполняет HMAC-SHA3-256 шифрование строки, выводит зашифрованную строку в виде Base64 строки
 dongle. Encrypt. FromString("hello world"). ByHmacSha3([]byte("dongle"), 256). ToBase64String() // gZM2f94oz1xGCttEmgSz3ZwYT0iL3Mur8FJsVPkMRGA=
 // Выполняет HMAC-SHA3-256 шифрование байтового массива, выводит зашифрованный байтовый массив в виде шестнадцатеричной строки
 dongle. Encrypt. FromBytes([]byte("hello world")). ByHmacSha3([]byte("dongle"), 256). ToHexBytes() // []byte("8193367fde28cf5c460adb449a04b3dd9c184f488bdccbabf0526c54f90c4460")
 // Выполняет HMAC-SHA3-256 шифрование байтового массива, выводит зашифрованный байтовый массив в виде Base64 строки
 dongle. Encrypt. FromBytes([]byte("hello world")). ByHmacSha3([]byte("dongle"), 256). ToBase64Bytes()
 ```FromBytes([]byte("привет мир")). ByHmacSha3([]byte("dongle"), 256). ToBase64Bytes() // []byte("gZM2f94oz1xGCttEmgSz3ZwYT0iL3Mur8FJsVPkMRGA=")// Выполняет HMAC-SHA3-384 шифрование строки, выводит зашифрованную строку в виде шестнадцатеричной строки
dongle.Encrypt.FromString("hello world").ByHmacSha3([]byte("dongle"), 384).ToHexString() // 3f76f5cda69cada3ee6b33f8458cd498b063075db263dd8b33f2a3992a8804f9569a7c86ffa2b8f0748babeb7a6fc0e7
// Выполняет HMAC-SHA3-384 шифрование строки, выводит зашифрованную строку в виде Base64 строки
dongle.Encrypt.FromString("hello world").ByHmacSha3([]byte("dongle"), 384).ToBase64String() // P3b1zaacraPuazP4RYzUmLBjB12yY92LM/KjmSqIBPlWmnyG/6K48HSLq+t6b8Dn
// Выполняет HMAC-SHA3-384 шифрование байтового массива, выводит зашифрованный байтовый массив в виде шестнадцатеричной строки
dongle.Encrypt.FromBytes([]byte("hello world")).ByHmacSha3([]byte("dongle"), 384).ToHexBytes() // []byte("3f76f5cda69cada3ee6b33f8458cd498b063075db263dd8b33f2a3992a8804f9569a7c86ffa2b8f0748babeb7a6fc0e7")
// Выполняет HMAC-SHA3-384 шифрование байтового массива, выводит зашифрованный байтовый массив в виде Base64 строки
dongle.Encrypt.FromBytes([]byte("hello world")).ByHmacSha3([]byte("dongle"), 384).ToBase64Bytes() // []byte("P3b1zaacraPuazP4RYzUmLBjB12yY92LM/KjmSqIBPlWmnyG/6K48HSLq+t6b8Dn")
// Выполняет HMAC-SHA3-512 шифрование строки, выводит зашифрованное значение в виде шестнадцатеричной строки
dongle.Encrypt.FromString("hello world").ByHmacSha3([]byte("dongle"), 512).ToHexString() // a99653d0407d659eccdeed43bb7cccd2e2b05a2c34fd3467c4198cf2ad26a466738513e88839fb55e64eb49df65bc52ed0fec2775bd9e086edd4fb4024add4a2
// Выполняет HMAC-SHA3-512 шифрование строки, выводит зашифрованное значение в виде Base64 строки
dongle.Encrypt.FromString("hello world").ByHmacSha3([]byte("dongle"), 512).ToBase64String() // qZZT0EB9ZZ7M3u1Du3zM0uKwWiw0/TRnxBmM8q0mpGZzhRPoiDn7VeZOtJ32W8Uu0P7Cd1vZ4Ibt1PtAJK3Uog== 
// Выполняет HMAC-SHA3-512 шифрование байтового массива, выводит зашифрованное значение в виде шестнадцатеричной строкиdongle. Encrypt. FromBytes([]byte("привет мир")). ByHmacSha3([]byte("dongle"), 512). ToHexBytes() // []byte("a99653d0407d659eccdeed43bb7cccd2e2b05a2c34fd3467c4198cf2ad26a466738513e88839fb55e64eb49df65bc52ed0fec2775bd9e086edd4fb4024add4a2")
 // Выполняет HMAC-SHA3-512 шифрование байтового массива, выводит зашифрованное значение в виде Base64 строки
 dongle. Encrypt. FromBytes([]byte("привет мир")). ByHmacSha3([]byte("dongle"), 512). ToBase64Bytes() // []byte("qZZT0EB9ZZ7M3u1Du3zM0uKwWiw0/TRnxBmM8q0mpGZzhRPoiDn7VeZOtJ32W8Uu0P7Cd1vZ4Ibt1PtAJK3Uog==")```
##### Шифрование HMAC-SHA224

```go
// Шифрует строку с помощью HMAC-SHA224, выводит шестнадцатеричное представление строки
dongle.Encrypt.FromString("hello world").ByHmacSha224([]byte("dongle")).ToHexString() // e15b9e5a7eccb1f17dc81dc07c909a891936dc3429dc0d940accbcec
// Шифрует строку с помощью HMAC-SHA224, выводит закодированное Base64 представление строки
dongle.Encrypt.FromString("hello world").ByHmacSha224([]byte("dongle")).ToBase64String() // 4VueWn7MsfF9yB3AfJCaiRk23DQp3A2UCsy87A====

// Шифрует байтовую последовательность с помощью HMAC-SHA224, выводит шестнадцатеричное представление байтовой последовательности
dongle.Encrypt.FromBytes([]byte("hello world")).ByHmacSha224([]byte("dongle")).ToHexBytes() // []byte("e15b9e5a7eccb1f17dc81dc07c909a891936dc3429dc0d940accbcec")
// Шифрует байтовую последовательность с помощью HMAC-SHA224, выводит закодированное Base64 представление байтовой последовательности
dongle.Encrypt.FromBytes([]byte("hello world")).ByHmacSha224([]byte("dongle")).ToBase64Bytes() // []byte("4VueWn7MsfF9yB3AfJCaiRk23DQp3A2UCsy87A==")
```

##### Шифрование HMAC-SHA256

```go
// Шифрует строку с помощью HMAC-SHA256, выводит шестнадцатеричное представление строки
dongle.Encrypt.FromString("hello world").ByHmacSha256([]byte("dongle")).ToHexString() // b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9
// Шифрует строку с помощью HMAC-SHA256, выводит закодированное Base64 представление строки
dongle.Encrypt.FromString("hello world").ByHmacSha256([]byte("dongle")).ToBase64String() // uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek=
```// Шифрует байтовую последовательность с помощью HMAC-SHA256, выводит шестнадцатеричное представление байтовой последовательности
dongle.Encrypt.FromBytes([]byte("hello world")).ByHmacSha256([]byte("dongle")).ToHexBytes() // []byte("b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9")
// Шифрует байтовую последовательность с помощью HMAC-SHA256, выводит закодированное Base64 представление байтовой последовательности
dongle.Encrypt.FromBytes([]byte("hello world")).ByHmacSha256([]byte("dongle")).ToBase64Bytes() // []byte("uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek=")
```##### Шифрование HMAC-SHA384```go
// Выполняет HMAC-SHA384 шифрование строки, выводит зашифрованный хеш в виде шестнадцатеричной строки
dongle.Encrypt.FromString("hello world").ByHmacSha384([]byte("dongle")).ToHexString() // 421fcaa740216a31bbcd1f86f2212e0c68aa4b156a8ebc2ae55b3e75c4ee0509ea0325a0570ae739006b61d91d817fe8
// Выполняет HMAC-SHA384 шифрование строки, выводит зашифрованный хеш в виде базовой 64-битной строки
dongle.Encrypt.FromString("hello world").ByHmacSha384([]byte("dongle")).ToBase64String() // Qh/Kp0AhajG7zR+G8iEuDGiqSxVqjrwq5Vs+dcTuBQnqAyWgVwrnOQBrYdkdgX/o
// Выполняет HMAC-SHA384 шифрование байтового массива, выводит зашифрованный хеш в виде шестнадцатеричной строки
dongle.Encrypt.FromBytes([]byte("hello world")).ByHmacSha384([]byte("dongle")).ToHexBytes() // []byte("421fcaa740216a31bbcd1f86f2212e0c68aa4b156a8ebc2ae55b3e75c4ee0509ea0325a0570ae739006b61d91d817fe8")
// Выполняет HMAC-SHA384 шифрование байтового массива, выводит зашифрованный хеш в виде базовой 64-битной строки
dongle.Encrypt.FromBytes([]byte("hello world")).ByHmacSha384([]byte("dongle")).ToBase64Bytes() // []byte("Qh/Kp0AhajG7zR+G8iEuDGiqSxVqjrwq5Vs+dcTuBQnqAyWgVwrnOQBrYdkdgX/o")
```##### Шифрование HMAC-SHA512

> Включает hmac-sha512, hmac-sha512-224, hmac-sha512-256```go
// Encrypts a string using HMAC-SHA512 and outputs the hexadecimal representation of the string
dongle.Encrypt.FromString("hello world").ByHmacSha512([]byte("dongle")).ToHexString() // d971b790bbc2a4ac81062bbffac693c9c234bae176c8faf5e304dbdb153032a826f12353964b4a4fb87abecd2dc237638a630cbad54a6b94b1f6ef5d5e2835d1
// Encrypts a string using HMAC-SHA512 and outputs the base64 encoded representation of the string
dongle.Encrypt.FromString("hello world").ByHmacSha512([]byte("dongle")).ToBase64String() // 2XG3kLvCpKyBBiu/+saTycI0uuF2yPr14wTb2xUwMqgm8SNTlktKT7h6vs0twjdjimMMutVKa5Sx9u9dXig10Q==
// Encrypts a byte array using HMAC-SHA512 and outputs the hexadecimal representation of the byte array
dongle.Encrypt.FromBytes([]byte("hello world")).ByHmacSha512([]byte("dongle")).ToHexBytes() // []byte("d971b790bbc2a4ac81062bbffac693c9c234bae176c8faf5e304dbdb153032a826f12353964b4a4fb87abecd2dc237638a630cbad54a6b94b1f6ef5d5e2835d1")
// Encrypts a byte array using HMAC-SHA512 and outputs the base64 encoded representation of the byte array
dongle.Encrypt.FromBytes([]byte("hello world")).ByHmacSha512([]byte("dongle")).ToBase64Bytes() // []byte("2XG3kLvCpKyBBiu/+saTycI0uuF2yPr14wTb2xUwMqgm8SNTlktKT7h6vs0twjdjimMMutVKa5Sx9u9dXig10Q==")
``````markdown
// Шифрует строку с помощью HMAC-SHA512-224, выводит шестнадцатеричное представление строки
dongle.Encrypt.FromString("hello world").ByHmacSha512([]byte("dongle"), 224).ToHexString() // c4145bcc385c29f0e5683cd5450be9deb522d556de3b046a7ffa1eb3
// Шифрует строку с помощью HMAC-SHA512-224, выводит закодированное Base64 представление строки
dongle.Encrypt.FromString("hello world").ByHmacSha512([]byte("dongle"), 224).ToBase64String() // xBRbzDhcKfDlaDzVRQvp3rUi1VbeOwRqf/oesw==
// Шифрует байтовый массив с помощью HMAC-SHA512-224, выводит шестнадцатеричное представление байтового массива
dongle.Encrypt.FromBytes([]byte("hello world")).ByHmacSha512([]byte("dongle"), 224).ToHexBytes() // []byte("c4145bcc385c29f0e5683cd5450be9deb522d556de3b046a7ffa1eb3")
// Шифрует байтовый массив с помощью HMAC-SHA512-224, выводит закодированное Base64 представление байтового массива
dongle.Encrypt.FromBytes([]byte("hello world")).ByHmacSha512([]byte("dongle"), 224).ToBase64Bytes() // []byte("xBRbzDhcKfDlaDzVRQvp3rUi1VbeOwRqf/oesw==")

// Выполняет HMAC-SHA512-256 шифрование строки, выводит зашифрованное значение в виде шестнадцатеричной строки
dongle.Encrypt.FromString("hello world").ByHmacSha512([]byte("dongle"), 256).ToHexString() // e99fae71bcb43651ae10e952989eadf897faccb43966ee5122bb1b1d82f7a7c2
// Выполняет HMAC-SHA512-256 шифрование строки, выводит зашифрованное значение в виде Base64 строки
dongle.Encrypt.FromString("hello world").ByHmacSha512([]byte("dongle"), 256).ToBase64String() // 6Z+ucby0NlGuEOlSmJ6t+Jf6zLQ5Zu5RIrsbHYL3p8I=
// Выполняет HMAC-SHA512-256 шифрование байтового массива, выводит зашифрованное значение в виде шестнадцатеричной строки
dongle.Encrypt.FromBytes([]byte("hello world")).ByHmacSha512([]byte("dongle"), 256).ToHexBytes() // []byte("e99fae71bcb43651ae10e952989eadf897faccb43966ee5122bb1b1d82f7a7c2")
```// Выполнить HMAC-SHA512-256 шифрование байтового массива, вывести зашифрованное значение в виде Base64 строки
dongle. Encrypt. FromBytes([]byte("hello world")). ByHmacSha512([]byte("dongle"), 256). ToBase64Bytes() // []byte("6Z+ucby0NlGuEOlSmJ6t+Jf6zLQ5Zu5RIrsbHYL3p8I=")
```sql
##### Шифрование HMAC-RIPMD160
``````go
// Шифрование строки методом HMAC-RIPMD160, вывод в виде шестнадцатеричной строки
dongle.Encrypt.FromString("hello world").ByHmacRipemd160([]byte("dongle")).ToHexString() // 3691AD040E80C43DC6E8FFE9BC6EF3D5BD8786B8
// Шифрование строки методом HMAC-RIPMD160, вывод в виде строки Base64
dongle.Encrypt.FromString("hello world").ByHmacRipemd160([]byte("dongle")).ToBase64String() // NpGtBA6AXD3G6P/pvG7z1b2Hhrg=

// Шифрование байтового массива методом HMAC-RIPMD160, вывод в виде шестнадцатеричного байтового массива
dongle.Encrypt.FromBytes([]byte("hello world")).ByHmacRipemd160([]byte("dongle")).ToHexBytes() // []byte("3691AD040E80C43DC6E8FFE9BC6EF3D5BD8786B8")
// Шифрование байтового массива методом HMAC-RIPMD160, вывод в виде байтового массива Base64
dongle.Encrypt.FromBytes([]byte("hello world")).ByHmacRipemd160([]byte("dongle")).ToBase64Bytes() // []byte("NpGtBA6AXD3G6P/pvG7z1b2Hhrg=")
```

##### Шифрование HMAC-SM3

```go
// Шифрование строки методом HMAC-SM3, вывод в виде шестнадцатеричной строки
dongle.Encrypt.FromString("hello world").ByHmacSm3([]byte("dongle")).ToHexString() // 8C733AAE1D553C466A08C3E9E5DAAC3E99AE220181C7C1BC8C2564961DE751B3
// Шифрование строки методом HMAC-SM3, вывод в виде строки Base64
dongle.Encrypt.FromString("hello world").ByHmacSm3([]byte("dongle")).ToBase64String() // jHM6rh1VPEZqCMPp5dqsPpmuIgGBx8G8jCVklh3nUbM=

// Шифрование байтового массива методом HMAC-SM3, вывод в виде шестнадцатеричного байтового массива
dongle.Encrypt.FromBytes([]byte("hello world")).ByHmacSm3([]byte("dongle")).ToHexBytes() // []byte("8C733AAE1D553C466A08C3E9E5DAAC3E99AE220181C7C1BC8C2564961DE751B3")
// Шифрование байтового массива методом HMAC-SM3, вывод в виде байтового массива Base64
dongle.Encrypt.FromBytes([]byte("hello world")).ByHmacSm3([]byte("dongle")).ToBase64Bytes() // []byte("jHM6rh1VPEZqCMPp5dqsPpmuIgGBx8G8jCVklh3nUbM=")
```##### Шифрование AES, расшифровка

```go
cipher := dongle.NewCipher()
cipher.SetMode(dongle.CBC) // CBC, CFB, OFB, CTR, ECB
cipher.SetPadding(dongle.PKCS7) // Нет, Пусто, Ноль, PKCS5, PKCS7, AnsiX923, ISO97971
cipher.SetKey("0123456789abcdef") // Длина ключа должна быть  Yöntem 16, 24 или 32 байта
// cipher.WithKey([]byte("0123456789abcdef"))
cipher.SetIV("0123456789abcdef") // Длина IV должна быть 16 байт, при режиме ECB IV не требуется
// cipher.WithIV([]byte("0123456789abcdef"))
```

// Шифрование строки с использованием AES, вывод незакодированной строки
rawString := dongle.Encrypt.FromString("hello world").ByAes(cipher).ToRawString()
// Расшифровка незакодированной строки с помощью AES, вывод строки
dongle.Decrypt.FromRawString(rawString).ByAes(cipher).ToString() // hello world

// Шифрование строки с использованием AES, вывод закодированной строки в шестнадцатеричном формате
dongle.Encrypt.FromString("hello world").ByAes(cipher).ToHexString() // c1e9b4529aac9793010f4677f6358efe
// Расшифровка закодированной строки в шестнадцатеричном формате с помощью AES, вывод строки
dongle.Decrypt.FromHexString("c1e9b4529aac9793010f4677f6358efe").ByAes(cipher).ToString() // hello world

// Шифрование строки с использованием AES, вывод закодированной строки в Base64
dongle.Encrypt.FromString("hello world").ByAes(cipher).ToBase64String() // wem0Upqsl5MBD0Z39jWO/g==
// Расшифровка закодированной строки в Base64 с помощью AES, вывод строки
dongle.Decrypt.FromBase64String("wem0Upqsl5MBD0Z39jWO/g==").ByAes(cipher).ToString() // hello world// Шифрование байтового слайса с использованием AES, вывод незакодированного байтового слайса
rawBytes := dongle.Encrypt.FromBytes([]byte("hello world")).ByAes(cipher).ToRawBytes()
// Расшифровка незакодированного байтового слайса с помощью AES, вывод байтового слайса
dongle.Decrypt.FromRawBytes(rawBytes).ByAes(cipher).ToBytes() // []byte("hello world")// Шифрование байтового слайса с использованием AES, вывод закодированного байтового слайса в шестнадцатеричном формате
dongle.Encrypt.FromBytes([]byte("hello world")).ByAes(cipher).ToHexBytes() // []byte("c1e9b4529aac9793010f4677f6358efe")
// Расшифровка закодированного байтового слайса в шестнадцатеричном формате с помощью AES, вывод байтового слайса
dongle.Decrypt.FromHexBytes([]byte("c1e9b4529aac9793010f4677f6358efe")).ByAes(cipher).ToBytes() // []byte("hello world")

// Шифрование байтового слайса с использованием AES, вывод закодированного байтового слайса в Base64
dongle.Encrypt.FromBytes([]byte("hello world")).ByAes(cipher).ToBase64Bytes() // []byte("ZdgjvfHFgaHe0cukLgPKUg==")
// Расшифровка закодированного байтового слайса в Base64 с помощью AES, вывод байтового слайса
dongle.Decrypt.FromBase64Bytes([]byte("wem0Upqsl5MBD0Z39jWO/g==")).ByAes(cipher).ToBytes() // []byte("hello world")

##### Blowfish шифрование, расшифровка
```go
cipher := модуль_шифрования.NewCipher()
cipher.SetMode(модуль_шифрования.CBC) // CBC, CFB, OFB, CTR, ECB
cipher.SetPadding(модуль_шифрования.PKCS7) // No, Empty, Zero, PKCS5, PKCS7, AnsiX923, ISO97971
cipher.SetKey("0123456789abcdef") // длина ключа должна быть от OnClickListener.LayoutParams.MATCH_PARENT до OnClickListener.LayoutParams.WRAP_CONTENT байт
// cipher.WithKey([]byte("0123456789abcdef"))
cipher.SetIV("12345678")          // длина вектора инициализации должна быть 8 байт, для режима ECB его установка не требуется
// cipher.WithIV([]byte("12345678"))
```

Исправлено:
- Удалены лишние символы после названий режимов шифрования.
- Исправлены диапазоны значений для ключей и векторов инициализации.Примечание: В данном контексте `dongle` заменено на `модуль_шифрования`, чтобы сохранить смысл оригинальной строки.// Шифрование строки Blowfish, вывод незакодированной строки
rawString := модуль_шифрования.Encrypt.FromString("hello world").ByBlowfish(cipher).ToRawString()
// Расшифровка незакодированной строки Blowfish, вывод строки
модуль_шифрования.Decrypt.FromRawString(rawString).ByBlowfish(cipher).ToString() // hello world// Шифрование строки Blowfish, вывод закодированной строки в hex
dongle.Encrypt.FromString("hello world").ByBlowfish(cipher).ToHexString() // c1e9b4529aac9793010f4677f6358efe
// Расшифровка закодированной строки в hex Blowfish, вывод строки
dongle.Decrypt.FromHexString("c1e9b4529aac9793010f4677f6358efe").ByBlowfish(cipher).ToString() // hello world

// Шифрование строки Blowfish, вывод закодированной строки Base64
dongle.Encrypt.FromString("hello world").ByBlowfish(cipher).ToBase64String() // ksNyTXILWZgtIaq5p7ufQA==
// Расшифровка закодированной строки Base64 Blowfish, вывод строки
dongle.Decrypt.FromBase64String("ksNyTXILWZgtIaq5p7ufQA==").ByBlowfish(cipher).ToString() // hello world

// Шифрование байтового среза Blowfish, вывод незакодированного байтового среза
rawBytes := dongle.Encrypt.FromBytes([]byte("hello world")).ByBlowfish(cipher).ToRawBytes()
// Расшифровка незакодированного байтового среза Blowfish, вывод байтового среза
dongle.Decrypt.FromRawBytes(rawBytes).ByBlowfish(cipher).ToBytes() // []byte("hello world")

// Шифрование байтового среза Blowfish, вывод закодированного байтового среза в hex
dongle.Encrypt.FromBytes([]byte("hello world")).ByBlowfish(cipher).ToHexBytes() // []byte("c1e9b4529aac9793010f4677f6358efe")
// Расшифровка закодированного байтового среза в hex Blowfish, вывод байтового среза
dongle.Decrypt.FromHexBytes([]byte("c1e9b4529aac9793010f4677f6358efe")).ByBlowfish(cipher).ToBytes() // []byte("hello world")

// Шифрование байтового среза Blowfish, вывод закодированного байтового среза Base64
dongle.Encrypt.FromBytes([]byte("hello world")).ByBlowfish(cipher).ToBase64Bytes() // []byte("ksNyTXILWZgtIaq5p7ufQA==")
// Расшифровка закодированного байтового среза Base64 Blowfish, вывод байтового среза
dongle.Decrypt.FromBase64Bytes([]byte("ksNyTXILWZgtIaq5p7ufQA==")).ByBlowfish(cipher).ToBytes() // []byte("hello world")

##### Дескриптор шифрования, дешифрования```go
cipher := dongle.NewCipher()
cipher.SetMode(dongle.CBC) // CBC, ECB, CFB, OFB, CTR
cipher.SetPadding(dongle.PKCS7) // No, Empty, Zero, PKCS5, PKCS7, AnsiX923, ISO97971
cipher.SetKey("12345678") // длина ключа должна быть 8 байт
// cipher.WithKey([]byte("12345678"))
cipher.SetIV("12345678") // длина вектора инициализации должна быть 8 байт
// cipher.WithIV([]byte("12345678"))

// Шифрование строки методом DES, вывод незакодированной строки
rawString := dongle.Encrypt.FromString("hello world").ByDes(cipher).ToRawString()
// Дешифрование незакодированной строки методом DES, вывод строки
dongle.Decrypt.FromRawString(rawString).ByDes(cipher).ToString() // hello world

// Шифрование строки методом DES, вывод закодированной строки в шестнадцатеричном формате
dongle.Encrypt.FromString("hello world").ByDes(cipher).ToHexString() // 0b2a92e81fb49ce1a43266aacaea7b81
// Дешифрование закодированной строки в шестнадцатеричном формате методом DES, вывод строки
dongle.Decrypt.FromHexString("0b2a92e81fb49ce1a43266aacaea7b81").ByDes(cipher).ToString() // hello world

// Шифрование строки методом DES, вывод закодированной строки в Base64
dongle.Encrypt.FromString("hello world").ByDes(cipher).ToBase64String() // CyqS6B+0nOGkMmaqyup7gQ==
// Дешифрование закодированной строки в Base64 методом DES, вывод строки
dongle.Decrypt.FromBase64String("CyqS6B+0nOGkMmaqyup7gQ==").ByDes(cipher).ToString() // hello world

// Шифрование массива байтов методом DES, вывод незакодированного массива байтов
rawBytes := dongle.Encrypt.FromBytes([]byte("hello world")).ByDes(cipher).ToRawBytes()
// Дешифрование незакодированного массива байтов методом DES, вывод массива байтов
dongle.Decrypt.FromRawBytes(rawBytes).ByDes(cipher).ToBytes() // []byte("hello world")
```// Шифрование массива байтов методом DES, вывод закодированного массива байтов в шестнадцатеричном формате
dongle.Encrypt.FromBytes([]byte("hello world")).ByDes(cipher).ToHexBytes() // []byte("0b2a92e81fb49ce1a43266aacaea7b81")
// Дешифрование закодированного массива байтов в шестнадцатеричном формате методом DES, вывод массива байтов
dongle.Decrypt.FromHexBytes([]byte("0b2a92e81fb49ce1a43266aacaea7b81")).ByDes(cipher).ToBytes() // []byte("hello world")

```// Зашифровать байтовый срез методом des, вывести зашифрованный байтовый срез, закодированный в base64
dongle.Encrypt.FromBytes([]byte("hello world")).ByDes(cipher).ToBase64Bytes() // []byte("CyqS6B+0nOGkMmaqyup7gQ==")
// Расшифровать байтовый срез, закодированный в base64, методом des, вывести расшифрованный байтовый срез
dongle.Decrypt.FromBase64Bytes([]byte("CyqS6B+0nOGkMmaqyup7gQ==")).ByDes(cipher).ToBytes() // []byte("hello world")
```

##### Шифрование и расшифровка 3DES

```go
cipher := dongle.NewCipher()
cipher.SetMode(dongle.CBC) // CBC, CFB, CTR, ECB, OFB
cipher.SetPadding(dongle.PKCS7) // No、Empty、Zero、PKCS5、PKCS7、AnsiX923、ISO97971
cipher.SetKey("123456781234567812345678") // Длина ключа должна быть  Yöntem 24 байта
// cipher.WithKey([]byte("123456781234567812345678"))
cipher.SetIV("12345678") // Длина вектора инициализации должна быть 8 байт
// cipher.WithIV([]byte("12345678"))

// Зашифровать строку с помощью 3DES, вернуть незакодированную строку
rawString := dongle.Encrypt.FromString("hello world").By3Des(cipher).ToRawString()
// Расшифровать незакодированную строку с помощью 3DES, вернуть строку
dongle.Decrypt.FromRawString(rawString).By3Des(cipher).ToString() // hello world
```// Зашифровать строку с помощью 3DES, вернуть шестнадцатеричное представление строки
dongle.Encrypt.FromString("hello world").By3Des(cipher).ToHexString() // 92c3724d720b59982d21aab9a7bb9f40
// Расшифровать шестнадцатеричное представление строки с помощью 3DES, вернуть строку
dongle.Decrypt.FromHexString("92c3724d720b59982d21aab9a7bb9f40").By3Des(cipher).ToString() // hello world// Зашифровать строку с помощью 3DES, вернуть закодированную строку Base64
dongle.Encrypt.FromString("hello world").By3Des(cipher).ToBase64String() // CyqS6B+0nOGkMmaqyup7gQ==
// Расшифровать закодированную строку Base64 с помощью 3DES, вернуть строку
dongle.Decrypt.FromBase64String("CyqS6B+0nOGkMmaqyup7gQ==").By3Des(cipher).ToString() // hello world

// Зашифровать массив байтов с помощью 3DES, вернуть незакодированный массив байтов
rawBytes := dongle.Encrypt.FromBytes([]byte("hello world")).By3Des(cipher).ToRawBytes()
// Расшифровать незакодированный массив байтов с помощью 3DES, вернуть массив байтов
dongle.Decrypt.FromRawBytes(rawBytes).By3Des(cipher).ToBytes() // []byte("hello world")

// Зашифровать массив байтов с помощью 3DES, вернуть шестнадцатеричное представление массива байтов
dongle.Encrypt.FromBytes([]byte("hello world")).By3Des(cipher).ToHexBytes() // []byte("92c3724d720b59982d21aab9a7bb9f40")
// Расшифровать шестнадцатеричное представление массива байтов с помощью 3DES, вернуть массив байтов
dongle.Decrypt.FromHexBytes([]byte("92c3724d720b59982d21aab9a7bb9f40")).By3Des(cipher).ToBytes() // []byte("hello world")

// Зашифровать байтовый срез с помощью 3DES шифра, вернуть зашифрованный байтовый срез, прошедший базовую шестнадцатеричную закодированную конвертацию
dongle.Encrypt.FromBytes([]byte("hello world")).By3Des(cipher).ToBase64Bytes() // []byte("CyqS6B+0nOGkMmaqyup7gQ==")
// Расшифровать байтовый срез, прошедший базовую шестнадцатеричную закодированную конвертацию, с помощью 3DES шифра, вернуть расшифрованный байтовый срез
dongle.Decrypt.FromBase64Bytes([]byte("CyqS6B+0nOGkMmaqyup7gQ==")).By3Des(cipher).ToBytes() // []byte("hello world")```go
pkcs1PublicKey := []byte(`-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAK12MTd84qkCZzp4iLUj8YSUglaFMsFlv9KlIL4+Xts40PK3+wbsXPEwc
ujGeUmdgMeZiK7SLLSz8QeE0v7Vs+cGK4Bs4qLtMGCiO6wEuyt10KsafTyBktFndk
/d/gBLr7B/b+9+HaMIIoJUdsFksdAg3cxTSpwVApe98loFNRfqDAgMBAAE=
-----END RSA PUBLIC KEY-----`)

pkcs1PrivateKey := []byte(`-----BEGIN RSA PRIVATE KEY-----
MIICXQIBAAKBgQCtdjE3fOKpAmc6eIi1I/GElIJWhTLBZb/SpSC+Pl7bONDyt/sG
7FzxMHLoxnlJnYDHmYiu0iy0s/EHhNL+1bPnBiuAbOKi7TBgojusBLsrddCrGn08
gZLRZ3ZP/oAS6+wf2/vfh2jCCKCVHbBZLHQIN3MU0qcFQKXvfJaBTUX6gwIDAQAB
AoGAFwAfEo56t5JcAcLNzccQVVYj2jkbO820G8hNiSxYA5WLD0QaAxcAU/Lqqbb3
ii1aUB0ppJS13NgnU6nnGGdZzUYBG1Hai6EkVyCGrI4amQ93AaVdKncL8gJ4RAmY
zPPUwSMEESsu24pS1NF1G1Y8C+28b/Wr0oqOsCvL6PhsMECQQDwsPJJoWRx7ZJE1
K5KLT0cXKyrIpyXY3I6tyA5imCzOzccf3d1vDgB0L9sdSO7bG3ceSwpAeiWEbg5j
GZemPzAkEAuH6U4pEI4AMbWnatpK55Rc235NDgmT3VyIuRaKC02YXAZ+jznFepXM
d4DTli4R9r3j2YVhUpyDVbdQpFH98DMQJAQpOvcU6DSkA80WOG7lCkPTlkUKgJY7
kdDwZoF/SW+vzWMbvQf3CgzV/Ak2+TgrRrbyDVZkJw45HjM4fyiRgoQJBALH/qlx
gPyQQs3O/s2KQBsm1auAE5IF5MLuVUZ69sF/mBko2hEXSqHnGV645TuKU0pCZz12g
a9WO3z6gaK0SaECQQDah1pKt9ViBBy4USXK3OWXEloHuTwmyr9AbLqqI5tQ2eNuH
0NkuJYQmnXmHLbKOELoYocldEBXmkzPXSN+X9kV
-----END RSA PRIVATE KEY-----`)

pkcs8PublicKey := []byte(`-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCqzZNa9VrcewyU6wDoV7Y9kAHq
X1VK0B3Rb6GNmQe4zLEfce7cVTaLrc4VGTKl35tADG1cRHqtaG4S/WttpiGZBhxJ
y4MpOXb6eIPiVLsn2lL+rJo5XdbSr3gyjxEOQQ97ihtw4lDd5wMo4bIOuw1LtMez
HC1outlM6x+/BB0BSQIDAQAB
-----END PUBLIC KEY-----`)
``````markdown
pkcs8PrivateKey := []byte(`-----BEGIN PRIVATE KEY-----
MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAKrNk1r1Wtx7DJTr
AOhXtj2QAepfVUrQHdFvoY2ZB7jMsR9x7txVNoutzhUZMqXfm0AMbVxEeq1obhL9
a22mIZkGHEnLgyk5dvp4g+JUuyfaUv6smjld1tKveDKPEQ5BD3uKG3DiUN3nAyjh
sg67DUu0x7McLWi62UzrH78EHQFJAgMBAAECgYAeo3nHWzPNURVUsUMcan96U5bE
YA2AugxfQVMNf2HvOGidZ2adh3udWrQY/MglERNcTd5gKriG2rDEH0liBecIrNKs
BL4lV+qHEGRUcnDDdtUBdGInEU8lve5keDgmX+/huXSRJ+3tYA5u9j+32RquVczv
Idtb5XnBLUl61k0osQJBAON5+eJjtw6xpn+pveU92BSHvaJYVyrLHwUjR07aNKb7
GlGVM3MGf1FCa8WQUo9uUzYxGLtg5Qf3sqwOrwPd5UsCQQDAOF/zWqGuY3HfV/1w
giXiWp8rc+S8tanMj5M37QQbYW5YLjUmJImoklVahv3qlgLZdEN5ZSueM5jfoSFt
Nts7AkBKoRDvSiGbi4MBbTHkzLZgfewkH/FxE7S4nctePk553fXTgCyh9ya8BRuQ
dHnxnpNkOxVPHEnnpEcVFbgrf5gjAkB7KmRI4VTiEfRgINhTJAG0VU7SH/N7+4cu
fPzfA+7ywG5c8Fa79wOB0SoB1KeUjcSLo5Ssj2fwea1F9dAeU90LAkBJQFofveaD
a3YlN4EQZOcCvJKmg7xwWuGxFVTZDVVEws7UCQbEOEEXZrNd9x0IF5kpPLR+rxua
RPgUNaDGIh5o
-----END PRIVATE KEY-----`)
```

###### 1. Шифрование с помощью открытого ключа RSA и расшифровка с помощью закрытого ключа
``````go
// Encryption of a string using the PKCS1 public key in RSA format
cipherText := dongle.Encrypt.FromString("hello world").ByRsa(pkcs1PublicKey)
// Decryption of a string encrypted with the PKCS1 public key using the PKCS1 private key and outputting the string
dongle.Decrypt.FromHexString(cipherText.ToHexString()).ByRsa(pkcs1PrivateKey).ToString() // hello world
// Decryption of a string encrypted with the PKCS1 public key using the PKCS1 private key and outputting the string after decoding from Base64
dongle.Decrypt.FromBase64String(cipherText.ToBase64String()).ByRsa(pkcs1PrivateKey).ToString() // hello world

// Encryption of a byte sequence using the PKCS1 public key in RSA format
cipherText := dongle.Encrypt.FromBytes([]byte("hello world")).ByRsa(pkcs1PublicKey)
// Decryption of a byte sequence encrypted with the PKCS1 public key using the PKCS1 private key and outputting the byte sequence
dongle.Decrypt.FromHexBytes(cipherText.ToHexBytes()).ByRsa(pkcs1PrivateKey).ToByte() // []bytes("hello world")
// Decryption of a byte sequence encrypted with the PKCS1 public key using the PKCS1 private key and outputting the byte sequence after decoding from Base64
dongle.Decrypt.FromBase64Bytes(cipherText.ToBase64Bytes()).ByRsa(pkcs1PrivateKey).ToByte() // []bytes("hello world")
```// Шифрование строки с использованием открытого ключа PKCS8 в формате RSA, вывод зашифрованной строки в формате HEX
cipherText := dongle.Encrypt.FromString("hello world").ByRsa(pkcs8PublicKey)
// Дешифрование строки, зашифрованной с помощью открытого ключа PKCS8, с использованием закрытого ключа PKCS8, вывод строки
dongle.Decrypt.FromHexString(cipherText.ToHexString()).ByRsa(pkcs8PrivateKey).ToString() // hello world
// Дешифрование строки, зашифрованной с помощью открытого ключа PKCS8, с использованием закрытого ключа PKCS8, вывод строки после декодирования Base64
dongle.Decrypt.FromBase64String(cipherText.ToBase64String()).ByRsa(pkcs8PrivateKey).ToString() // hello world// Шифрование байтовой последовательности с использованием открытого ключа PKCS8 в формате RSA, вывод зашифрованной байтовой последовательности в формате HEX
cipherText := dongle.Encrypt.FromBytes([]byte("hello world")).ByRsa(pkcs8PublicKey)
// Дешифрование байтовой последовательности, зашифрованной с помощью открытого ключа PKCS8, с использованием закрытого ключа PKCS8, вывод байтовой последовательности
dongle.Decrypt.FromHexBytes(cipherText.ToHexBytes()).ByRsa(pkcs8PrivateKey).ToByte() // []byte("hello world")
// Дешифрование байтовой последовательности, зашифрованной с помощью открытого ключа PKCS8, с использованием закрытого ключа PKCS8, вывод байтовой последовательности после декодирования Base64
dongle.Decrypt.FromBase64Bytes(cipherText.ToBase64Bytes()).ByRsa(pkcs8PrivateKey).ToByte() // []byte("hello world")

```go
// Шифрование строки с использованием приватного ключа PKCS1 в формате RSA
cipherText := dongle.Encrypt.FromString("hello world").ByRsa(pkcs1PrivateKey)
// Дешифрование строки, зашифрованной hex-кодировкой, с использованием публичного ключа PKCS1 в формате RSA, вывод строки
dongle.Decrypt.FromHexString(cipherText.ToHexString()).ByRsa(pkcs1PublicKey).ToString() // hello world
// Дешифрование строки, зашифрованной Base64-кодировкой, с использованием публичного ключа PKCS1 в формате RSA, вывод строки
dongle.Decrypt.FromBase64String(cipherText.ToBase64String()).ByRsa(pkcs1PublicKey).ToString() // hello world
```// Шифрование байтового массива с использованием приватного ключа PKCS1 в формате RSA
cipherText := dongle.Encrypt.FromBytes([]byte("hello world")).ByRsa(pkcs1PrivateKey)
// Дешифрование байтового массива, зашифрованного hex-кодировкой, с использованием публичного ключа PKCS1 в формате RSA, вывод байтового массива
dongle.Decrypt.FromHexBytes(cipherText.ToHexBytes()).ByRsa(pkcs1PublicKey).ToByte() // []byte("hello world")
// Дешифрование байтового массива, зашифрованного Base64-кодировкой, с использованием публичного ключа PKCS1 в формате RSA, вывод байтового массива
dongle.Decrypt.FromBase64Bytes(cipherText.ToBase64Bytes()).ByRsa(pkcs1PublicKey).ToByte() // []byte("hello world")

// Шифрование строки с использованием приватного ключа PKCS8 в формате RSA, вывод зашифрованной строки в hex-формате
cipherText := dongle.Encrypt.FromString("hello world").ByRsa(pkcs8PrivateKey)
// Дешифрование строки, зашифрованной hex-кодировкой, с использованием публичного ключа PKCS8 в формате RSA, вывод строки
dongle.Decrypt.FromHexString(cipherText.ToHexString()).ByRsa(pkcs8PublicKey).ToString() // hello world
// Дешифрование строки, зашифрованной Base64-кодировкой, с использованием публичного ключа PKCS8 в формате RSA, вывод строки
dongle.Decrypt.FromBase64String(cipherText.ToBase64String()).ByRsa(pkcs8PublicKey).ToString() // hello world// Шифрование байтового массива с использованием приватного ключа PKCS8 в формате RSA, вывод зашифрованного байтового массива в hex-формате
cipherText := dongle.Encrypt.FromBytes([]byte("hello world")).ByRsa(pkcs8PrivateKey)
// Расшифрование байтового массива, зашифрованного hex-кодировкой, с использованием публичного ключа PKCS8 в формате RSA, вывод байтового массива
dongle.Decrypt.FromHexBytes(cipherText.ToHexBytes()).ByRsa(pkcs8PublicKey).ToByte() // []bytes("hello world")
// Расшифрование байтового массива, зашифрованного Base64-кодировкой, с использованием публичного ключа PKCS8 в формате RSA, вывод байтового массива
dongle.Decrypt.FromBase64Bytes(cipherText.ToBase64Bytes()).ByRsa(pkcs8PublicKey).ToByte() // []bytes("hello world")
```##### Шифрование и дешифровка TEA```> При шифровании открытого текста, превышающего 8 байт, производится заполнение пустыми строками и последующее групповое шифрование; количество раундов должно быть четным, по умолчанию — 64.

```go
// Шифрование строки методом TEA, вывод в виде шестнадцатеричной строки
dongle.Encrypt.FromString("hello world").ByTea([]byte("0123456789abcdef")).ToHexString() // bfa8d956247c0dcecfe2b0ef44b08aab
// Расшифровка шестнадцатеричной строки методом TEA, вывод в виде строки
dongle.Decrypt.FromHexString("bfa8d956247c0dcecfe2b0ef44b08aab").ByTea([]byte("0123456789abcdef")).ToString() // hello world

// Шифрование строки методом TEA, вывод в виде закодированной Base64 строки
dongle.Encrypt.FromString("hello world").ByTea([]byte("0123456789abcdef")).ToBase64String() // v6jZViR8Dc7P4rDvRLCKqw==
// Расшифровка закодированной Base64 строки методом TEA, вывод в виде строки
dongle.Decrypt.FromBase64String("v6jZViR8Dc7P4rDvRLCKqw==").ByTea([]byte("0123456789abcdef")).ToString() // hello world

// Шифрование массива байтов методом TEA, вывод в виде шестнадцатеричной строки
dongle.Encrypt.FromBytes([]byte("hello world")).ByTea([]byte("0123456789abcdef"), 32).ToHexBytes() // []byte("bfa8d956247c0dcecfe2b0ef44b08aab")
// Расшифровка шестнадцатеричной строки методом TEA, вывод в виде массива байтов
dongle.Decrypt.FromHexBytes([]byte("bfa8d956247c0dcecfe2b0ef44b08aab")).ByTea([]byte("0123456789abcdef"), 64).ToBytes() // []byte("hello world")
```// Шифрование массива байтов методом TEA, вывод в виде закодированной Base64 строки
dongle.Encrypt.FromBytes([]byte("hello world")).ByTea([]byte("0123456789abcdef"), 32).ToBase64Bytes() // []byte("v6jZViR8Dc7P4rDvRLCKqw==")
// Расшифровка закодированной Base64 строки методом TEA, вывод в виде массива байтов
dongle.Decrypt.FromBase64Bytes([]byte("v6jZViR8Dc7P4rDvRLCKqw==")).ByTea([]byte("0123456789abcdef"), 64).ToBytes() // []byte("hello world")##### Шифрование и расшифровка RC4

```go
// Шифрование строки методом RC4, вывод в виде шестнадцатеричной строки
dongle.Encrypt.FromString("hello world").ByRc4([]byte("dongle")).ToHexString() // eba154b4cb5a9038dbbf9d
// Расшифровка шестнадцатеричной строки методом RC4, вывод в виде строки
dongle.Decrypt.FromHexString("eba154b4cb5a9038dbbf9d").ByRc4([]byte("dongle")).ToString() // hello world
```// Применение RC4 шифрования к строке, вывод строки, закодированной в Base64
dongle.Encrypt.FromString("hello world").ByRc4([]byte("dongle")).ToBase64String() // 66FUtMtakDjbv50=
// Расшифровка строки, закодированной в Base64 с помощью RC4
dongle.Decrypt.FromBase64String("66FUtMtakDjbv50=").ByRc4([]byte("dongle")).ToString() // hello world
// Применение RC4 шифрования к срезу байтов, вывод зашифрованного среза байтов в виде шестнадцатеричной строки
dongle.Encrypt.FromBytes([]byte("hello world")).ByRc4([]byte("dongle")).ToHexBytes() // []byte("eba154b4cb5a9038dbbf9d")
// Расшифровка шестнадцатеричной строки с помощью RC4, вывод среза байтов
dongle.Decrypt.FromBase64Bytes([]byte("hello world")).ByRc4([]byte("dongle")).ToBytes() // []byte("eba154b4cb5a9038dbbf9d")

// Применение RC4 шифрования к срезу байтов, вывод зашифрованного среза байтов в виде базовой 64-битной строки
dongle.Encrypt.FromBytes([]byte("hello world")).ByRc4([]byte("dongle")).ToBase64Bytes() // []byte("66FUtMtakDjbv50=")
// Расшифровка базовой 64-битной строки с помощью RC4, вывод среза байтов
dongle.Decrypt.FromBase64Bytes([]byte("66FUtMtakDjbv50=")).ByRc4([]byte("dongle")).ToBytes() // []byte("hello world")
```

##### Шифрование SM3```go
// Шифрование строки методом SM3, вывод зашифрованной строки в виде шестнадцатеричной строки
dongle.Encrypt.FromString("hello world").BySm3().ToHexString() // 44f0061e69fa6fdfc290c494654a05dc0c053da7e5c52b84ef93a9d67d3fff88
// Шифрование строки методом SM3, вывод зашифрованной строки в виде базовой 64-битной строки
dongle.Encrypt.FromString("hello world").BySm3().ToBase64String() // RPAGHmn6b9/CkMSUZUoF3AwFPaflxSuE75Op1n0//4g=
```// Шифрование среза байтов методом SM3, вывод зашифрованного среза байтов в виде шестнадцатеричной строки
dongle.Encrypt.FromBytes([]byte("hello world")).BySm3().ToHexBytes() // []byte("44f0061e69fa6fdfc290c494654a05dc0c053da7e5c52b84ef93a9d67d3fff88")
// Шифрование среза байтов методом SM3, вывод зашифрованного среза байтов в виде базовой 64-битной строки
dongle.Encrypt.FromBytes([]byte("hello world")).BySm3().ToBase64Bytes() // []byte("RPAGHmn6b9/CkMSUZUoF3AwFPaflxSuE75Op1n0//4g=")

```

#### Подпись & проверка подписи

##### Подпись & проверка с использованием bcrypt

> Количество раундов принимает значения от 4 до 31, по умолчанию равно 10.
``````go
// Создание подписи для строки с помощью Bcrypt
sign := dongle.Sign.FromString("hello world").ByBcrypt()
// Проверка подписи без использования кодирования, с использованием Bcrypt
dongle.Verify.FromRawString(sign.ToRawString(), "hello world").ByBcrypt().ToBool() // true
// Проверка подписи, закодированной в шестнадцатеричном представлении, с использованием Bcrypt
dongle.Verify.FromHexString(sign.ToHexString(), "hello world").ByBcrypt().ToBool() // true
// Проверка подписи, закодированной в базовой 64-битной строке, с использованием Bcrypt
dongle.Verify.FromBase64String(sign.ToBase64String(), "hello world").ByBcrypt().ToBool() // true
```// Создание подписи с помощью bcrypt для байтового среза
sign := dongle.Sign.FromBytes([]byte("hello world")).ByBcrypt(10)
// Проверка подписи незакодированного байтового среза с использованием bcrypt
dongle.Verify.FromRawBytes([]byte(sign.ToRawBytes()), []byte("hello world")).ByBcrypt(10).ToBool() // true
// Проверка подписи закодированного в hex байтового среза с использованием bcrypt
dongle.Verify.FromHexBytes([]byte(sign.ToHexBytes()), []byte("hello world")).ByBcrypt(10).ToBool() // true
// Проверка подписи закодированной в base64 байтового среза с использованием bcrypt
dongle.Verify.FromBase64Bytes([]byte(sign.ToBase64Bytes()), []byte("hello world")).ByBcrypt(10).ToBool() // true
``````go
##### Подпись и проверка Ed25519

```go
var publicKey, privateKey []byte

// Генерация незакодированной пары ключей (публичный и приватный ключ)
publicKey, privateKey, _ = ed25519.GenerateKey(nil)

// Получение публичного ключа, закодированного в hex
hexPublicKey := dongle.Encode.FromBytes(publicKey).ByHex().ToBytes()
// Получение приватного ключа, закодированного в hex
hexPrivateKey := dongle.Encode.FromBytes(privateKey).ByHex().ToBytes()
// Получение публичного ключа, закодированного в base64
base64PublicKey := dongle.Encode.FromBytes(publicKey).ByBase64().ToBytes()
// Получение приватного ключа, закодированного в base64
base64PrivateKey := dongle.Encode.FromBytes(privateKey).ByBase64().ToBytes()
```// Создание подписи строки с использованием незакодированного приватного ключа методом Ed25519
sign := dongle.Sign.FromString("hello world").ByEd25519(privateKey, dongle.Raw)
// Проверка подписи незакодированной строки с использованием незакодированного публичного ключа методом Ed25519
dongle.Verify.FromRawString(sign.ToRawString(), "hello world").ByEd25519(publicKey, dongle.Raw).ToBool() // true
// Проверка подписи строки, закодированной в hex, с использованием незакодированного публичного ключа методом Ed25519
dongle.Verify.FromHexString(sign.ToHexString(), "hello world").ByEd25519(publicKey, dongle.Raw).ToBool() // true
// Проверка подписи строки, закодированной в base64, с использованием незакодированного публичного ключа методом Ed25519
dongle.Verify.FromBase64String(sign.ToBase64String(), "hello world").ByEd25519(publicKey, dongle.Raw).ToBool() // true
```// Подписать строку ed25519 с помощью шестнадцатеричного закрытого ключа
sign := dongle.Sign.FromString("привет мир").ByEd25519(hexPrivateKey, dongle.Hex)
// Провести проверку подписи ed25519 для незакодированной строки подписи с использованием шестнадцатеричного открытого ключа
dongle.Verify.FromRawString(sign.ToRawString(), "привет мир").ByEd25519(hexPublicKey, dongle.Hex).ToBool() // true
// Провести проверку подписи ed25519 для шестнадцатеричной строки подписи с использованием шестнадцатеричного открытого ключа
dongle.Verify.FromHexString(sign.ToHexString(), "привет мир").ByEd25519(hexPublicKey, dongle.Hex).ToBool() // true
// Провести проверку подписи ed25519 для базовой64 строки подписи с использованием шестнадцатеричного открытого ключа
dongle.Verify.FromBase64String(sign.ToBase64String(), "привет мир")# ЭЦП с использованием алгоритма Ed25519

```go
ByEd25519(hexPublicKey, dongle.Hex).ToBool() // true
```## Подпись строки с помощью закрытого ключа, закодированного в base64
```go
sign := dongle.Sign.FromString("привет мир").ByEd25519(base64PrivateKey, dongle.Base64)
```
## Проверка подписи с помощью открытого ключа, закодированного в base64
```go
dongle.Verify.FromRawString(sign.ToRawString(), "привет мир").ByEd2551 Yöntem(base64PublicKey, dongle.Base64).ToBool() // true
```
## Проверка подписи, закодированной в hex, с помощью открытого ключа, закодированного в base64
```go
dongle.Verify.FromHexString(sign.ToHexString(), "привет мир").ByEd25519(base64PublicKey, dongle.Base64).ToBool() // true
```
## Проверка подписи, закодированной в base64, с помощью открытого ключа, закодированного в base64
```go
dongle.Verify.FromBase64String(sign.ToBase64String(), "привет мир").ByEd25519(base64PublicKey, dongle.Base64).ToBool() // true
```

---

##### RSA-подпись и проверка подписи

> Поддерживаемые хэш-алгоритмы: MD5, SHA1, SHA224, SHA256, SHA384, SHA512, RIPEMD160

```go
pkcs1PublicKey := []byte(`-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAK12MTd84qkCZzp4iLUj8YSUglaFMsFlv9KlIL4+Xts40PK3+wbsXPEw
cujGeUmdgMeZiK7SLLSz8QeE0v7Vs+cGK4Bs4qLtMGCiO6wEuyt10KsafTyBktFn
dk/+gBLr7B/b+9+HaMIIoJUdsFksdAg3cxTSpwVApe98loFNRfqDAgMBAAE=
-----END RSA PUBLIC KEY-----`)

pkcs1PrivateKey :=  []byte(`-----BEGIN RSA PRIVATE KEY-----
MIICXQIBAAKBgQCtdjE3fOKpAmc6eIi1I/GElIJWhTLBZb/SpSC+Pl7bONDyt/sG
7FzxMHLoxnlJnYDHmYiu0iy0s/EHhNL+1bPnBiuAbOKi7TBgojusBLsrddCrGn08
gZLRZ3ZP/oAS6+wf2/vfh2jCCKCVHbBZLHQIN3MU0qcFQKXvfJaBTUX6gwIDAQAB
AoGAFwAfEo56t5JcAcLNzccQVVYj2jkbO820G8hNiSxYA5WLD0QaAxcAU/Lqqbb3
ii1aUB0ppJS13NgnU6nnGGdZzUYBG1Hai6EkVyCGrI4amQ93AaVdKncL8gJ4RZAm
YzPPUwSMEESsu24pS1NF1G1Y8C+28b/Wr0oqOsCvL6PhsMECQQDwsPJJoWRx7ZJw
E1K5KLT0cXKyrIpyXY3I6tyA5imCzOzccf3d1vDgB0L9sdSO7bG3ceSwpAeiWEbg
5jGZemPzAkEAuH6U4pEI4AMbWnatpK55Rc235NDgmT3VyIuRaKC02YXAZ+jznFep
XMd4DTli4R9r3j2YVhUpyDVbdQpFH98DMQJAQpOvcU6DSkA80WOG7lCkPTlkUKgJ
Y7kdDwZoF/+SW+vzWMbvQf3CgzV/Ak2+TgrRrbyDVZkJw45HjM4fyiRgoQJBALH/
/qlxgPyQQs3O/s2KQBsm1auAE5IF5MLuVUZ69sF/mBko2hEXSqHnGV645TuKU0pC
Zz12ga9WO3z6gaK0SaECQQDah1pKt9ViBBy4USXK3OWXEloHuTwmyr9AbLqqI5tQ
2eNuH0NkuJYQmnXmHLbKOELoYocldEBXmkzPXSN+X9kV
-----END RSA PRIVATE KEY-----`)
```pkcs8PublicKey :=  []byte(`-----BEGIN PUBLIC КЛЮЧ-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCqzZNa9VrcewyU6wDoV7Y9kAHq
X1VK0B3Rb6GNmQe4zLEfce7cVTaLrc4VGTKl35tADG1cRHqtaG4S/WttpiGZBhxJ
y4MpOXb6eIPiVLsn2lL+rJo5XdbSr3gyjxEOQQ97ihtw4lDd5wMo4bIOuw1LtMez
HC1outlM6x+/BB0BSQIDAQAB
-----Конец PUBLIC КЛЮЧ-----`)
```pkcs8PrivateKey :=  []byte(`-----BEGIN PRIVATE КЛЮЧ-----
MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAKrNk1r1Wtx7DJTr
AOhXtj2QAepfVUrQHdFvoY2ZB7jMsR9x7txVNoutzhUZMqXfm0AMbVxEeq1obhL9
a22mIZkGHEnLgyk5dvp4g+JUuyfaUv6smjld1tKveDKPEQ5BD3uKG3DiUN3nAyjh
sg67DUu0x7McLWi62UzrH78EHQFJAgMBAAECgYAeo3nHWzPNURVUsUMcan96U5bE
YA2AugxfQVMNf2HvOGidZ2adh3udWrQY/MglERNcTd5gKriG2rDEH0liBecIrNKs
BL4lV+qHEGRUcnDDdtUBdGInEU8lve5keDgmX+/huXSRJ+3tYA5u9j+32RquVczv
Idtb5XnBLUl61k0osQJBAON5+eJjtw6xpn+pveU92BSHvaJYVyrLHwUjR07aNKb7
GlGVM3MGf1FCa8WQUo9uUzYxGLtg5Qf3sqwOrwPd5UsCQQDAOF/zWqGuY3HfV/1w
giXiWp8rc+S8tanMj5M37QQbYW5YLjUmJImoklVahv3qlgLZdEN5ZSueM5jfoSFt
Nts7AkBKoRDvSiGbi4MBbTHkzLZgfewkH/FxE7S4nctePk553fXTgCyh9ya8BRuQ
dHnxnpNkOxVPHEnnpEcVFbgrf5gjAkB7KmRI4VTiEfRgINhTJAG0VU7SH/N7+4cu
fPzfA+7ywG5c8Fa79wOB0SoB1KeUjcSLo5Ssj2fwea1F9dAeU90LAkBJQFofveaD
a3YlN4EQZOcCvJKmg7xwWuGxFVTZDVVEws7UCQbEOEEXZrNd9x0IF5kpPLR+rxua
RPgUNaDGIh5o
-----Конец PRIVATE КЛЮЧ-----`)

// Создание RSA подписи для строки
sign := dongle.Sign.FromString("hello world").ByRsa(pkcs1PrivateKey, dongle.MD5)
// Проверка RSA подписи для незакодированной строки
dongle.Verify.FromRawString(sign.ToRawString(), "hello world").ByRsa(pkcs1PublicKey, dongle.MD5).ToBool() // true
// Проверка RSA подписи для шестнадцатеричной закодированной строки
dongle.Verify.FromHexString(sign.ToHexString(), "hello world").ByRsa(pkcs1PublicKey, dongle.MD5).ToBool() // true
// Проверка RSA подписи для Base64 закодированной строки
dongle.Verify.FromBase64String(sign.ToBase64String(), "hello world").ByRsa(pkcs1PublicKey, dongle.MD5).ToBool() // true// Создание RSA подписи для байтового массива
sign := dongle.Sign.FromBytes([]byte("hello world")).ByRsa(pkcs8PrivateKey, dongle.SHA512)
// Проверка RSA подписи для незакодированного байтового массива
dongle.Verify.FromRawBytes(sign.ToRawBytes(), []byte("hello world")).ByRsa(pkcs1PublicKey, dongle.SHA512).ToBool() // true
// Проверка RSA подписи для шестнадцатеричного закодированного байтового массива
dongle.Verify.FromHexBytes(sign.ToHexBytes(), []byte("hello world")).ByRsa(pkcs1PublicKey, dongle.SHA512).ToBool() // true
// Проверка RSA подписи для Base64 закодированного байтового массива
dongle.Verify.FromBase64Bytes(sign.ToBase64Bytes(), []byte("hello world")).ByRsa(pkcs1PublicKey, dongle.SHA512).ToBool() // true
```#### OpenSSL```##### RSA ключи

```go
// Generation of an RSA key pair in PKCS#1 format
publicKey, privateKey := openssl.RSA.GenKeyPair(openssl.PKCS1, 1024)
// Generation of an RSA key pair in PKCS#8 format
publicKey, privateKey := openssl.RSA.GenKeyPair(openssl.PKCS8, 2048)

// Verification of the correspondence between RSA keys
openssl.RSA.VerifyKeyPair(publicKey, privateKey) // true
openssl.RSA.VerifyKeyPair(publicKey, []byte("xxx")) // false

// Checking if a key is a public RSA key
openssl.RSA.IsPublicKey(publicKey) // true
openssl.RSA.IsPublicKey(privateKey) // false

// Checking if a key is a private RSA key
openssl.RSA.IsPrivateKey(privateKey) // true
openssl.RSA.IsPrivateKey(publicKey) // false

// Parsing a public RSA key
pub, err := openssl.RSA.ParsePublicKey(publicKey)
// Parsing a private RSA key
pri, err := openssl.RSA.ParsePrivateKey(privateKey)

// Formatting a public RSA key in PKCS#1 format with headers, trailers, and line breaks
openssl.RSA.FormatPublicKey(openssl.PKCS1, publicKey1)
// Formatting a public RSA key in PKCS#8 format with headers, trailers, and line breaks
openssl.RSA.FormatPublicKey(openssl.PKCS8, publicKey8)
// Formatting a private RSA key in PKCS#1 format with headers, trailers, and line breaks
openssl.RSA.FormatPrivateKey(openssl.PKCS1, privateKey1)
// Formatting a private RSA key in PKCS#8 format with headers, trailers, and line breaks
openssl.RSA.FormatPrivateKey(openssl.PKCS8, privateKey8)

// Compression of an RSA key, removal of headers, trailers, and line breaks
keyBytes, err := openssl.RSA.CompressKey(key)

// Exporting a public key from a private RSA key
publicKey, err := openssl.RSA.ExportPublicKey(privateKey)
```### Обработка ошибок

> Если несколько ошибок происходят одновременно, возвращается только первая ошибка, следующая ошибка возвращается после того как предыдущая была обработана.

```go
e := dongle.Encrypt.FromString("hello world").ByRsa([]byte("xxxx"))
if e.Error != nil {
    // Обработка ошибок...
    log.Fatal(e.Error)
}
fmt.Println(e.ToString())
// Вывод
rsa: невалидный публичный ключ, убедитесь что публичный ключ корректен
```

### Примеры проектов

* [openssl/openssl](https://github.com/openssl/openssl)
* [javascript/crypto-js](https://github.com/brix/crypto-js)
* [nodejs/crypto](https://nodejs.org/api/crypto.html)
* [java/jasypt](https://github.com/jasypt/jasypt)

### Поддержка

`Dongle` — это независимый от коммерческих интересов открытый проект. Если вы хотите поддержать `Dongle`, вы можете купить кофе для разработчиков [здесь](https://www.gouguoyin.com/zanzhu.html).

### Благодарность

`Dongle` получил бесплатную лицензию от JetBrains, за что выражаю благодарность.

<a href="https://www.jetbrains.com"><img src="https://github-oss.oss-cn-beijing.aliyuncs.com/jetbrains.png" height="100" alt="JetBrains"/></a>