Go实现凯撒密码加密解密

本篇文章主要是结合我之前面试的各种经历和实战开发中遇到的问题解决经验整理的，希望这篇《Go实现凯撒密码加密解密》对你有很大帮助！欢迎收藏，分享给更多的需要的朋友学习~

1 凯撒密码加密

凯撒密码（英语：Caesar cipher），或称凯撒加密、凯撒变换、变换加密，是一种最简单且最广为人知的加密技术。

凯撒密码是一种替换加密技术，明文中的所有字母都在字母表上向后（或向前）按照一个固定数目进行偏移后被替换成密文。

例如，当偏移量是 3 的时候，所有的字母 A 将被替换成 D；B 变成E，以此类推。这个加密方法是以罗马共和时期凯撒的名字命名的，据称当年凯撒曾用此方法与其将军们进行联系。

在文本上使用凯撒密码来移动字符。调用 strings.Map 方法。

明文字母表：ABCDEFGHIJKLMNOPQRSTUVWXYZ

密文字母表：DEFGHIJKLMNOPQRSTUVWXYZABC

设计思想

• 设置明文和移动步长（秘文）
• 将清晰的文本转换为小写，准备清晰的文本字节切片和密文切片
• 每个明文字符根据位移的步长旋转并存储在密文片中
• 返回密文

2 Go实现

凯撒密码一般以密码形式交付。比如这串代码“exxegoexsrgi”是密码。

通过移动字母，我们可以对消息进行编码。这阻止了随意的窥探。

在 Go 中，我们可以使用 strings.Map 方法来实现这一点。

2.1 导入包

import (
    "fmt"
    "strings" // Include string operation related methods
)

2.2 编写 caesar 方法

然后让我们来编写 caesarEn() 凯撒密码加密方法。

这会接收一个字符串并返回一个修改过的字符串。

它会移动字符，然后将字符移动到有效范围。

// 凯撒密码加密
func caesarEn(strRaw string, step byte) string {
    //1. 将文本转为小写
    str_raw := strings.ToLower(strRaw)
    //2. 定义步长
    step_move := step
    //3. 将字符串转换为明文字符切片
    str_slice_src := []byte(str_raw)
    fmt.Println("Clear text character slice:", str_slice_src)
    //4. 创建一个密文字符切片
    str_slice_dst := str_slice_src
    //5.循环处理文本切片
    for i := 0; i 
3 凯撒密码解密
思想：

• 设置密文和位移步骤
• 准备密文字符切片和明文字符切片
• 每个密文的字符根据位移步长旋转，并存储在明文切片中
• 返回明文

Go 凯撒解密代码：

//2. 凯撒密码解密
func caesarDe(strCipher string, step byte) string {
    //1. 将文本转为小写
    str_cipher := strings.ToLower(strCipher)
    //2. 替代步长
    step_move := step
    //3. 将字符串转换为明文字符切片
    str_slice_src := []byte(str_cipher)
    fmt.Println("Ciphertext character slice:", str_slice_src)
    //4. 创建一个密文字符切片
    str_slice_dst := str_slice_src
    //5. 循环处理字符文本切片
    for i := 0; i = 97+step_move {
            str_slice_dst[i] = str_slice_src[i] - step_move
        } else { //7. 如果明文字符超出范围，则加上 26 减去位移后的步长
            str_slice_dst[i] = str_slice_src[i] + 26 - step_move
        }
    }
    //8. Output results
    fmt.Println("The decryption result is:", step_move, str_slice_dst, string(str_slice_dst))
    return string(str_slice_dst)
}

4 其他实现

package main
import (
	"errors"
	"fmt"
	"reflect"
	"regexp"
)
var TBL = []rune("abcdefghijklmnopqrstuvwxyz")
var CLUES = []string{"this", "the", "that"}
var (
	ErrLength = errors.New("invalid length")
	ErrChar = errors.New("invalid char")
	ErrNoClue = errors.New("no clue word")
	ErrShift = errors.New("invalid shift value")
)
func Encrypt(in string, sh int) (enc string, err error) {
	err = assert(in)
	if sh  80 {
		err = ErrLength
	}
	return
}
func shift(in string, sh int) (out string) {
	for _, v := range in {
		if v == '.' || v == ' ' || v == '\r' || v == '\n' {
			out += string(v)
			continue
		}
		i := indexOf(TBL, v)
		len := len(TBL)
		var ii int = (i + sh) % len
		if ii  len {
			ii -= len
		}
		out += string(TBL[ii])
	}
	return
}
func subtract(left rune, right rune) (out int) {
	l := indexOf(TBL, left)
	r := indexOf(TBL, right)
	out = l - r
	if out  len(in)-2 {
			break
		}
		subin = append(subin, subtract([]rune(in)[i], []rune(in)[i+1]))
	}
	// return
	return subin
}
func indexOf(target []rune, searchChar rune) int {
	for i, v := range target {
		if v == searchChar {
			return i
		}
	}
	return -1
}
func main() {
	in := "xlmw mw xli tmgxyvi xlex m xsso mr xli xvmt."
	fmt.Printf("in : '%s'\n", in)
	out, sh, err := Decrypt(in)
	fmt.Printf("out: '%s'\n", out)
	fmt.Printf("sh : %d\n", sh)
	fmt.Printf("err: %v\n", err)
}

5 测试

package main
import (
	"fmt"
	"strings"
)
func caesar(r rune, shift int) rune {
	// Shift character by specified number of places.
	// ... If beyond range, shift backward or forward.
	s := int(r) + shift
	if s > 'z' {
		return rune(s - 26)
	} else if s < 'a' {
		return rune(s + 26)
	}
	return rune(s)
}
func main() {
	value := "test"
	fmt.Println(value)
	// Test the caesar method in a func argument to strings.Map.
	value2 := strings.Map(func(r rune) rune {
		return caesar(r, 18)
	}, value)
	value3 := strings.Map(func(r rune) rune {
		return caesar(r, -18)
	}, value2)
	fmt.Println(value2, value3)
	value4 := strings.Map(func(r rune) rune {
		return caesar(r, 1)
	}, value)
	value5 := strings.Map(func(r rune) rune {
		return caesar(r, -1)
	}, value4)
	fmt.Println(value4, value5)
	value = "exxegoexsrgi"
	result := strings.Map(func(r rune) rune {
		return caesar(r, -4)
	}, value)
	fmt.Println(value, result)
}

运行该程序：

test
lwkl test
uftu test
exxegoexsrgi attackatonce

总结

本文简单介绍了一个有意思的密码学中的凯撒密码，该算法是一种替换加密技术，并在 Go 代码中实现了该算法的加密和解密过程，更多关于Go凯撒密码加解密的资料请关注golang学习网其它相关文章！

以上就是《Go实现凯撒密码加密解密》的详细内容，更多关于golang的资料请关注golang学习网公众号！