# go-chaos

**Repository Path**: chenjipdc/go-chaos

## Basic Information

- **Project Name**: go-chaos
- **Description**: go utils
- **Primary Language**: Go
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2020-09-10
- **Last Updated**: 2020-12-19

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# go-chaos
## cipher
### hash usage
```go
bs, err := MD5([]byte(src))

bs, err := SHA1([]byte(src))

bs, err := SHA224([]byte(src))

bs, err := SHA256([]byte(src))

bs, err := SHA384([]byte(src))

bs, err := SHA512([]byte(src))

bs, err := HMACMD5([]byte(src), []byte(key))

bs, err := HMACSHA1([]byte(src), []byte(key))

bs, err := HMACSHA224([]byte(src), []byte(key))

bs, err := HMACSHA256([]byte(src), []byte(key))

bs, err := HMACSHA384([]byte(src), []byte(key))

bs, err := HMACSHA512([]byte(src), []byte(key))

bs, err := SHA3224([]byte(src))

bs, err := SHA3256([]byte(src))

bs, err := SHA3384([]byte(src))

bs, err := SHA3512([]byte(src))
```

### aes usage
```go
// cfb encrypt
aescfb := AesCipher{
    Src: []byte(aesSrc),
    Key: []byte(aes256Key),
    T:   AES_256_CFB,
}
dst, _ := aescfb.Encrypt()
// cfb decrypt
aescfb.Src = dst
src, _ := aescfb.Decrypt()

// =============================================
// cbc encrypt
aescbc := AesCipher{
    Src: []byte(aesSrc),
    Key: []byte(aes128Key),
    T:   AES_128_CBC,
}
dst, _ := aescbc.Encrypt()
// cbc decrypt
aescbc.Src = dst
src, _ := aescbc.Decrypt()
```

### rsa usage
```go
// generate public/private key
err := GenerateKey(1024, "./pem", func(prv string, pub string) {
    fmt.Println("private key: ", prv)
    fmt.Println("public key: ", pub)
})

// encrypt
pub := RsaPub{
    PubKey: code.Base64DecodeString(public1024),
    Msg:    []byte(rsaMsg),
}

r := RsaCipher{
    Pub: &pub,
}
bs, err := r.Encrypt()

// decrypt
prv := RsaPrv{
    PrvKey: code.Base64DecodeString(private1024),
    Cipher: bs,
}
r.Prv = &prv
bs, err = r.Decrypt()

// sign
r := RsaCipher{
    Prv: &RsaPrv{
        PrvKey: code.Base64DecodeString(private1024),
    },
    Pub: &RsaPub{
        PubKey: code.Base64DecodeString(public1024),
    },
    Hash: crypto.SHA256,
}
bs, err := r.Sign([]byte(aesSrc))

// very sign
if !r.VerySign([]byte(aesSrc), code.Base64DecodeString(sha256VerySignData)) {
    t.Error("very sign failed")
} else {
    fmt.Println("very sign succeed")
}
```

----

## code
### base64
```go
str := Base64EncodeString(str)

bs := Base64DecodeString(str)

str := Base64Encode(bs)

bs := Base64Decode(bs)

```

----